# # # Rules to Define Identifiers in Python :-

# 1. Allowed Characters in Python :-
    # a to z
    # A to Z
    # 0 to 9
    # _(Underscore)

cash = 10

cas$h = 10

  Cell In[4], line 1
    cas$h = 10
       ^
SyntaxError: invalid syntax

cash_amount = 10

# 2. Identifier should not start with digit

total123 = 100

123total = 100

  Cell In[8], line 1
    123total = 100
      ^
SyntaxError: invalid decimal literal

# 3. Python identifiers are case sensitive

total = 10

Total = 20

TOTAL = 30

# 4. no length limit, but not recommended to take lengthy identifiers

# 5. we cannot use keyword or reserved characters as identifiers

x = 10

if = 20

  Cell In[29], line 1
    if = 20
       ^
SyntaxError: invalid syntax

# # Note :- 
    # x --> normal variable or public variable
    # _x --> protected variable
    # __x --> private variable
    
    # __x__ --> magical word
    # ex. __name__, __add__, __doc__, __sub__

__x = 10
type(__x)

int

# # # Reserved Words :-

# Some words are reserved to represent some functionality or meaning

# We have only 35 reserved words in Python

# True, False, None ===> Values.Reserved Literals

# and, or, not, is

# if, elif, else

# while, for, break, continue, return, in, yield

# try, except, finally, raise, assert

# import, from, as, class, def, pass, global, nonlocal, lambda, del, with

# # In Python 3.5 version new keyword introduced in Python :-

# async, await

# For asynchronous processing

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

# 1. All reserved words contain only alphabet symbols

# 2. The only reserved words contain upper case aplhabet symbol
#       True, False, None

# 3. Switch statement is not applicable in Python

# 4. do-while loop is not there

# 5. no keywords like int, float, boolean etc

# # # Data Types :-

# Data Type Represent the type of data represented by a variable

x = 10
x = True
x = 10.5
# Dynamically Typed: Python, JavaScript, ShellScripting etc

# int x = 10;
# boolean b = true;
# Statically Typed: Java, C, C++

# # Types of Data Types :-
    # int
    # float
    # complex
    # bool
    # str
    
    # list
    # tuple
    # set
    # frozenset
    # dict
    
    # bytes
    # bytearray
    # range
    # None

# # The 3 most commonly used in python's in built functions :-

# In Linux everything is treated as a File
# In Python everything is treated as Object

# x = 10
# 1. print(x)
# 2. type(x)
# 3. id(x) -->Address of Object

x = 10

print(x)

10

type(x)

int

id(x)

140731415577672

x = [10, 20, 30, 40, 50, 60, 70, 80]

print(x)
print(type(x))
print(id(x))

[10, 20, 30, 40, 50, 60, 70, 80]
<class 'list'>
2362951932544

# # # int Data Type :-

# To represent integral values

x = 10
print(type(x))

<class 'int'>

# # In Java we have :-

    # byte: -128 to +127
    # short: -32768 to 32767
    # int: -2147483648 to 2147483647
    # long: -2^63 to 2^63-1

x = 12134154687464634163746743216546874316574687431324865746431349874674321658746

# We have only 2 data types :-
    # int
    # long

# # Note :- In Python 2 we have int and long data type but in Python 3 we have only int data type

# # We can represent int values in multiple ways :-

    # 1. Decimal Form(base-10)
    # 2. Binary Form(base-2)
    # 3. Octal Form(base-8)
    # 4. Hexa Decimal Form(base-16)

# # 1. Decimal Form(base-10) :-

# The allowed digits are 0 to 9

# Example:
    # x = 12345

# # 2. Binary Form(base-2) :-

# The allowed digits are 0 to 1
# The number should be prefixed with 0b or 0B

# Example:
    # a = 0B1111
    # a = 0b1111

a = 1111
b = 0b1111

print(a)
print(b)

print(type(a))
print(type(b))

1111
15
<class 'int'>
<class 'int'>

# Convert Binary to Integer :-

    # ( 1    1    1    1 ) = (?)
    #  2^3  2^2  2^1  2^0

    # 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0
    # 1*8 + 1*4 + 1*2 + 1*1
    # 8 + 4 + 2 + 1
    # => 15

# # 3. Octal Form(base-8) :-

# The allowed digits are 0 to 7
# The number should be prefixed with 0o or 0O

# Example:
    # a = 0O0123
    # a = 0o0123

a = 0o0123
b = 0O0123

print(a)
print(b)

print(type(a))
print(type(b))

83
83
<class 'int'>
<class 'int'>

# Convert Octal to Integer :-

    # ( 0    1    2    3 ) = (?)
    #  8^3  8^2  8^1  8^0

    # 0*8^3 + 1*8^2 + 2*8^1 + 3*8^0
    # 0*512 + 1*64 + 2*8 + 3*1
    # 0 + 64 + 16 + 3
    # => 83

a = 0o123
b = 0b11

print(a)
print(b)

print(a + b)

83
3
86

# # 4. Hexa Decimal Form(base-16) :-

# The allowed digits are:
# 0 to 9, A to F

# A-->10
# B-->11
# C-->12
# D-->13
# E-->14
# F-->15

# A - F or a - f

# The number should be prefixed with 0x or 0X

# Example:
    # a = 0x0123Face
    # a = 0X0123Face

a = 0x0123Face
b = 0X0123Face

print(a)
print(b)

print(type(a))
print(type(b))

19135182
19135182
<class 'int'>
<class 'int'>

# Base-2 0 to 1
# Base-8 0 to 7
# Base-10 0 to 9
# Base-16 0 to 15

a = 0X012
print(a)

18

# Convert Hexa Decimal to Integer :-

    # (  0     1     2 ) = (?)
    #  16^2  16^1  16^0

    # 0*16^2 + 1*16^1 + 2*16*0
    # 0*256 + 1*16 + 2*1
    # 0 + 16 + 2
    # => 18

# # Base Conversion Functions :-

    # 1. bin()
    # 2. oct()
    # 3. hex()

# bin(x)--> Provides Equivalent Binary Value

# x can be any value like ocatl or decimal or hexa decimal number

a = 10
print(a)

b = bin(a)
print(b)

10
0b1010

print(bin(10))
print(bin(0o10))
print(bin(0x10))

0b1010
0b1000
0b10000

print(oct(10))

0o12

print(hex(10))

0xa

# # # Float Data Type :-

# Number with decimal point

f = 1.023

f = 0b1.1101

  Cell In[5], line 1
    f = 0b1.1101
           ^
SyntaxError: invalid syntax

f = 0o1.1101

  Cell In[6], line 1
    f = 0o1.1101
           ^
SyntaxError: invalid syntax

f = 0x1.1101

  Cell In[7], line 1
    f = 0x1.1101
           ^
SyntaxError: invalid syntax

# Float values we should specify only in decimal format

# Exponential form or Scientific notation
f = 1.2e3
print(f)

1200.0

f = 1.2E3
print(f)

1200.0

# We can represent big values in less memory

a = 120000000000000000000000000000000000000
print(a)

b = 12e16
print(b)

120000000000000000000000000000000000000
1.2e+17

# Conditions for Float Data Type :-

# 1. with decimal point
# 2. only in decimal
# 3. exponential form

# # # Complex Data Type :-

# In C, C++, Java-->complex data type not available

# Format :-
    # a+bj

    # a is real number
    # b is imaginary part
    # j is fixed variable

# For a we can use any base
# For b we should use only decimal form

c = 10 + 20j
print(c)

(10+20j)

c = -10 -25j
print(c)

(-10-25j)

# For a, b we can use both int, float values

c = 10.5 + 20.6j
print(c)

(10.5+20.6j)

c = 0B1111 + 20j
print(c)

(15+20j)

c = 0B1111 + 0b0111j

  Cell In[25], line 1
    c = 0B1111 + 0b0111j
                      ^
SyntaxError: invalid binary literal

a = 10 + 20j
b = 20 + 30j

print(a+b)
print(a-b)
print(a/b)
print(a*b)

(30+50j)
(-10-10j)
(0.6153846153846154+0.0769230769230769j)
(-400+700j)

c = 10*20j      # 10*(0+20j)
print(c)

200j

a = 10 + 20.5j

print(a.real)
print(a.imag)

10.0
20.5

a = True + 20.5j
print(a)

(1+20.5j)

# # # Boolean Data Type :-

# boolean values / logical values

# Example:
    # True --> 1
    # False --> 0

a = True
print(a)

b = False
print(b)

True
False

#  Comparison Operation:
age = 30
if age > 25:
    print('AGE is greater than 25')

AGE is greater than 25

True + True

2

True + False

1

True * False

0

True + Truej

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[48], line 1
----> 1 True + Truej

NameError: name 'Truej' is not defined

True + 20j

(1+20j)

# # # Str Data Type :-

# str --> string

# Any sequence of character within either single quotes or double quotes

s = 'Pulkit'
print(s)

Pulkit

s = "Pulkit"
print(s)

Pulkit

s = Pulkit

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[63], line 1
----> 1 s = Pulkit

NameError: name 'Pulkit' is not defined

s = 'Pulkit"

  Cell In[64], line 1
    s = 'Pulkit"
        ^
SyntaxError: unterminated string literal (detected at line 1)

s = '''Pulkit
    Chahal
    Python
    Practice'''

print(s)

Pulkit
    Chahal
    Python
    Practice

# Multi line String Literals :-

# triple quotes
# triple single quotes
# triple double quotes

s = """Pulkit
    Chahal
    Python
    Practice"""

print(s)

Pulkit
    Chahal
    Python
    Practice

s = "Python classes by 'Durga Sir' are average"
print(s)

Python classes by 'Durga Sir' are average

s = 'Python classes by "Durga Sir" are average'
print(s)

Python classes by "Durga Sir" are average

s = 'Python 'classes' by "Durga Sir" are average'

  Cell In[71], line 1
    s = 'Python 'classes' by "Durga Sir" are average'
                 ^
SyntaxError: invalid syntax

s = '''Python 'classes' by "Durga Sir" are average'''
print(s)

Python 'classes' by "Durga Sir" are average

s1 = '''Pulkit'''
s2 = 'Pulkit'
s3 = "Pulkit"

s1

'Pulkit'

s2

'Pulkit'

s3

'Pulkit'

s = 'Python \'classes\' by "Durga Sir" are average'
print(s)

Python 'classes' by "Durga Sir" are average

s = "Python \'classes\' by \"Durga Sir\" are average"
print(s)

Python 'classes' by "Durga Sir" are average

# We use strings:-

# 1. To define multiline string literals
# 2. To use single quote or double quote as normal character

s = 'durga'

s[0]

'd'

s[1]

'u'

s[2]

'r'

s[10]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[90], line 1
----> 1 s[10]

IndexError: string index out of range

#  +ve index always from left to right
#  -ve index always from right to left

s[-1]

'a'

s[-2]

'g'

s[-3]

'r'

s[-6]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[98], line 1
----> 1 s[-6]

IndexError: string index out of range

s[len(s)-1]

'a'

# # # Slice Operator :-

# peice --> part

# [] to retreive part(slice) of the string

# s[begin:end] -> returns substring from index to end-1 index

s = 'abcdefghijklmnopqrstuvwxyz'

s[5:11] # begin to end-1

'fghijk'

# If we are taking begin, then it will consider from begining of the string i.e default value is : 0

s[:8] # from 0 to 7

'abcdefgh'

# If we are not specifying end index until end of string

s[3:] # from 3 to end of string

'defghijklmnopqrstuvwxyz'

s[:] # from 0 to end of string

'abcdefghijklmnopqrstuvwxyz'

# s and s[:]

s

'abcdefghijklmnopqrstuvwxyz'

s[:]

'abcdefghijklmnopqrstuvwxyz'

# Slice operaator won't raise any IndexError.

# If the index is out of range, then it will consider upto available characters only.

s[0:2689] # from 0 to last

'abcdefghijklmnopqrstuvwxyz'

s[26] # IndexError: string index out of range

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[19], line 1
----> 1 s[26]

IndexError: string index out of range

s[3:5] # from begin index to end-1
        # from 3 to 4

'de'

s1 = 'aabcdefghijklmnopqrstuvwxyz             '

s1[:24656874]

'aabcdefghijklmnopqrstuvwxyz             '

s1[154687:1564687463]

''

s[2:7]

'cdefg'

s[7:2]

''

s[7:4] # from 7 to 3rd index in forward direction

''

# s[begin:end:step]

# Print the given string with first character as uppercase

s = 'durga'
s[0].upper()+s[1:]

'Durga'

# Print the given string with last character as uppercase

s = 'durga'
s[0:-1] + s[-1].upper()
# or
s[0:len(s)-1] + s[-1].upper()

'durgA'

# First and last character capital

s = 'pulkitchahal'
s[0].upper() + s[1:len(s)-1] + s[-1].upper()

'PulkitchahaL'

# # # Mathematical Operator for the String :-

s = 'pulkit' + 'chahal'
s

'durgasoft'

s = '     ' + 'chahal'
s

'     chahal'

s = 'durga' + 10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[52], line 1
----> 1 s = 'durga' + 10

TypeError: can only concatenate str (not "int") to str

s = 10 + 'durga'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[51], line 1
----> 1 s = 10 + 'durga'

TypeError: unsupported operand type(s) for +: 'int' and 'str'

s = '10' + 'durga'
s

'10durga'

s = 'durga' + '10'
s

'durga10'

# If we apply + operator for the strings both arguments should be str type only

# String Repition Operator(* -> Multiplication) ->

s = 'durga' * 5
s

'durgadurgadurgadurgadurga'

s = 5 * 'durga'
s

'durgadurgadurgadurgadurga'

s = 'durga' * 'soft'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[63], line 1
----> 1 s = 'durga' * 'soft'

TypeError: can't multiply sequence by non-int of type 'str'

# int + int
# str + str

# int * str
# str * int

# if we apply * for string one argument should be int

s = 2 * 'ab' * 3
s

'abababababab'

# # # Fundamental data types of Python :-

# int
# float
# complex
# bool
# str

# # # Type Casting :-

# int()
# float()
# complex()
# bool()
# str()

# # 1. int() ->

# We can use this function to convert from other types to int

# int(x)

# We can convert from any type to int type except comlex type.

# If we want to convert str to int type, string should represent only integral value and should be specified only in decimal form(base-10)

int(10.5)

10

int('10')

10

int('10.5')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[77], line 1
----> 1 int('10.5')

ValueError: invalid literal for int() with base 10: '10.5'

int(True)

1

int(10+20j)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[76], line 1
----> 1 int(10+20j)

TypeError: int() argument must be a string, a bytes-like object or a real number, not 'complex'

int('0B1001')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[78], line 1
----> 1 int('0B1001')

ValueError: invalid literal for int() with base 10: '0B1001'

int('durga')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[2], line 1
----> 1 int('durga')

ValueError: invalid literal for int() with base 10: 'durga'

# float --> int   int(10.5)
# complex --> int   int(10+20j)  # Error
# bool --> int  int(True)-->1
# str --> int   int('123')

# # 2. float() :-

# convert from other types to float type

# int --> float     float(10)
# complex --> float    float(10+20j) # Error
# bool --> float      float(True)
# str --> float       float('10')   float('10.5')

# cannot convert complex to float

# str should contains either integral value or floating point value, but compulsory we should use base-10 only

float(0B01010)

10.0

float('0B01010')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[65], line 1
----> 1 float('0B01010')

ValueError: could not convert string to float: '0B01010'

float(10+20j)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[66], line 1
----> 1 float(10+20j)

TypeError: float() argument must be a string or a real number, not 'complex'

float(True)

1.0

float('10')

10.0

float('10.5')

10.5

float(0X01011)

4113.0

float('ten')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[71], line 1
----> 1 float('ten')

ValueError: could not convert string to float: 'ten'

# # 3. complex() :-

# from other types to complex type
# a+bj

# From any type complex is possible

# complex(x), complex(x,y)

# complex(x):
#     x will become real part
#     imaginary part will become 0

# complex(x,y):
#     x will become real part
#     y will become imaginary part

# The second argument can not be string.

# If the first argument is string, then we can not pass second argument.

complex(10)

(10+0j)

complex(10.5)

(10.5+0j)

complex(True)

(1+0j)

complex('10')

(10+0j)

complex('10.5')

(10.5+0j)

complex('10.5j')

10.5j

complex('ten')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[77], line 1
----> 1 complex('ten')

ValueError: complex() arg is a malformed string

complex(10,5)

(10+5j)

complex(10.5,2.5)

(10.5+2.5j)

complex(True,False)

(1+0j)

complex('10','20')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[38], line 1
----> 1 complex('10','20')

TypeError: complex() can't take second arg if first is a string

complex(10,'20')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[39], line 1
----> 1 complex(10,'20')

TypeError: complex() second arg can't be a string

complex('10',20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[40], line 1
----> 1 complex('10',20)

TypeError: complex() can't take second arg if first is a string

complex(10,True)

(10+1j)

complex(10.5,False)

(10.5+0j)

complex(True, 10.5)

(1+10.5j)

complex('10',True)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[8], line 1
----> 1 complex('10',True)

TypeError: complex() can't take second arg if first is a string

complex(0B0111, 0X10134)

(7+65844j)

# # 4. bool() :-

# From other types to bool

# int --> bool        zero means False and non-zero means True
#         bool(0) ==> False
#         bool(1) ==> True
#         bool(2) ==> True

# float --> bool        zero means False and non-zero means True
#         bool(0.0) ==> False
#         bool(0.0001) ==> True

# complex --> bool        If both real and imaginary parts are zero then it is False otherwise it is True
#         bool(0+0j) ==> False
#         bool(0+0.1j) ==> True

# str --> bool        If string is empty then False else True
#         bool('True') ==> True
#         bool('False') ==> True
#         bool('Yes') ==> True
#         bool('No') ==> True
#         bool('') ==> False

bool(0)

False

bool(1)

True

bool(2)

True

bool(-2)

True

bool(0.0)

False

bool(0.0001)

True

bool(0+0j)

False

bool(0+0.1j)

True

bool('True')

True

bool(' ')

True

bool('')

False

bool('False')

True

# # 5. str() :-

# can convert any type to str

str(10)

'10'

str(10.5)

'10.5'

str(10+20j)

'(10+20j)'

str(True)

'True'

str(0B01111)

'15'

# # # Fundamental Data Types Vs Immutability :-

# All Fundamental Data Types are immutable

# In Python everything is treated as object only

# Immutable ==> we cannot change

# Once we creates an object, we cannot change its content.

# If we are trying to change the content, with those cahnges a new object will be created.

x = 10
y = x

print(id(x))
print(id(y))

140731415577672
140731415577672

y = y+1

print(id(x))
print(id(y))

140731415577672
140731415577704

x = True
print(id(x))

y = False
print(id(y))

140731414104640
140731414104672

x = 10
print(id(x))

x = float(x)
print(id(x))

140731415577672
1348341995856

x = 10
print(id(x))

x = x+1
print(id(x))

140731415577672
140731415577704

# # # Fundamental Data Types :-

# int, float, complex, bool, str

# # # Immutability

# # # Immutability Concept :-

# PVM ==> Intelligent

a = 10
b = 10
c = 10

print(id(a))
print(id(b))
print(id(c))

140709893870664
140709893870664
140709893870664

# With Immutability :-

# 1. Memory utilization will be improved.

# 2. Performace also will be improved.

a = 10.5
b = 10.5

print(id(a))
print(id(b))

print(a is b)

2189640694544
2189669176080
False

a = 10
b = 10

print(id(a))
print(id(b))

print(a is b)

140731415577672
140731415577672
True

a = 256
b = 256

print(id(a))
print(id(b))

print(a is b)

140731415585544
140731415585544
True

a = 257
b = 257

print(id(a))
print(id(b))

print(a is b)

2189662697680
2189669186096
False

a = True
b = True

print(id(a))
print(id(b))

print(a is b)

140731414104640
140731414104640
True

a = 'hi'
b = 'hi'

print(id(a))
print(id(b))

print(a is b)

2189573497072
2189573497072
True

a = 10+20j
b = 10+20j

print(id(a))
print(id(b))

print(a is b)

2189669171984
2189669185744
False

# # Note :- For Previous Python Versions ==> 
#         For two different variables(a, b) id will be same except for float type and complex type.

#   For new Python Versions ==>
#         For two different variables(a, b) id will be same for all type.

# Search for an object is available or not?

# Immutability :-

#     Once we creates an object, we cannot change content of that object.
#     If we are trying to change, with those changes a new object wil be created.

# Till how much value reuse can be done?

# int ==> 0 to 256

l = [10, 20, 30, 40]

print(l)

print(id(l))

l[0] = 7777

print(l)

print(id(l))

[10, 20, 30, 40]
1597873346176
[7777, 20, 30, 40]
1597873346176

# If variavble is saved in stack and object in heap, then ID of v1, v2, v3 etc should be different from object ' HYDERABAD' itself..
# How would we check ID or addreass of variable itself?

# id(v1) --> Address of object pointed by v1
# id(v2)

# # Note :- All Fundamental Data Types are Immutable.
#         ex. int, float, bool, complex, str

l1 = [10, 20, 30, 40]
l2 = l1

print(l1)
print(l2)

l1[0] = 777

print(l1)
print(l2)

l2[1] = 888

print(l1)
print(l2)

print(id(l1))
print(id(l2))

print(l1 is l2)

[10, 20, 30, 40]
[10, 20, 30, 40]
[777, 20, 30, 40]
[777, 20, 30, 40]
[777, 888, 30, 40]
[777, 888, 30, 40]
2189669521536
2189669521536
True

l1 = [10, 20, 30, 40]
l2 = [10, 20, 30, 40]

print(l1)
print(l2)

print(id(l1))
print(id(l2))

print(l1 is l2)

[10, 20, 30, 40]
[10, 20, 30, 40]
2189669519232
2189669540416
False

# # # Collection Related Data Types :-

a = 10
b = 10.5
c = True
d = 'durga'

name = 'durga'
names = ['durga', 'ravi', 'shiva']

# Collection Related Data Types :-

#     list
#     tuple
#     set
#     frozenset
#     dict
#     bytes
#     bytearray
#     range

# [] ==> list
# () ==> tuple
# {} ==> set
# {100:'durga', 200:'ravi'} ==> dict

# # list :-

# If we want to represent a group of values as a single entity where insertoion oreder preserved and duplicates are allowed.

list = [10, 10.5, 'durga', True, 10, 10, 10.5]
list

[10, 10.5, 'durga', True, 10, 10, 10.5]

# Properties of List :-

#     1. Insertion order preserved.

#     2. Duplicates are allowed.

#     3. Heterogeneous objects are alllowed.

#     4. Values should be enclosed within [].

#     5. Index and slice are applicable.

#     6. Growable in nature.

#     7. Mutable

list[0]

10

list[-1]

10.5

list[2:5]

['durga', True, 10]

list[0:9:2]

[10, 'durga', 10, 10.5]

list

[10, 10.5, 'durga', True, 10, 10, 10.5]

list.append('ravi')

list

[10, 10.5, 'durga', True, 10, 10, 10.5, 'ravi']

list.append('shiva')

list

[10, 10.5, 'durga', True, 10, 10, 10.5, 'ravi', 'shiva']

list.remove(10)

list

[10.5, 'durga', True, 10, 10, 10.5, 'ravi', 'shiva']

# # Tuple Data Type :-

# It is exactly same as list except that it is immutable

# Read only version of List ==> Tuple

# Tuple Properties :-

#     1. Insertion Order is preserved.

#     2. Indexing and slicing concepts are applicable.

#     3. Duplicates are allowed.

#     4. Heterogenous Objects are allowed.

#     5. ()

#     6. Immutable

#     7. Not Growable

tuple = (10, 20, 30, 40, 10, 'durga', True, 10.5)
tuple

(10, 20, 30, 40, 10, 'durga', True, 10.5)

tuple[0]

10

tuple[0:5]

(10, 20, 30, 40, 10)

tuple[0:6:2]

(10, 30, 10)

tuple.append(10)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[64], line 1
----> 1 tuple.append(10)

AttributeError: 'tuple' object has no attribute 'append'

tuple.remove(10)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[94], line 1
----> 1 tuple.remove(10)

AttributeError: 'tuple' object has no attribute 'remove'

# If content is not fixed and keep om changing ==> List
# Facebook comment: comment

# If content is fixed and won't change ==> Tuple
# Bank account type: Saving or Current

l = [10, 20, 30, 40]
# more memory

t = (10, 20, 30, 40)
# less memory

# Accessing elements is also very fast in Tuple.

# Performance is more for Tuple.

# # Difference b/w List and Tuple : -

# List :-
#     1. Mutable
#     2. [] (Square Brackets)
#     3. More Memory
#     4. Low Performance
#     5. Content not Fixed
#     6. Growable
#     7. Dynamic in Nature

# Tuple :-
#     1. Unmutable
#     2. () (Round Brackets or Parentheses)
#     3. Less Memory
#     4. More Performance
#     5. Content Fixed
#     6. Not Growable
#     7. Static in Nature

t = () # 0 elements
type(t)

tuple

t = (10) # 1 elements is not tuple untill ',' is not present
type(t)

int

t = (10,)
type(t)

tuple

t = (,)
type(t)

  Cell In[92], line 1
    t = (,)
         ^
SyntaxError: invalid syntax

l = [10]
type(l)

list

l = [,]

  Cell In[27], line 1
    l = [,]
         ^
SyntaxError: invalid syntax

t = 10,20,30,40
type(t)

tuple

# In case of Tuple Parantheses are optional

t = 10
type(t)

int

t = 10,
type(t)

tuple

# # Set Data Type :-

# Properties of Set:-

#     1. Dupicates are not allowed

#     2. Order is not Important

#     3. Indexing and Slicing concepts are not applicable

#     4. Heterogeneous objects are allowed

#     5. Mutable

#     6. Growable

#     7. {}

set = {10,20,-30,'durga','apple',10.5,10,20,10.5,'durga','shyam'}
set

{-30, 10, 10.5, 20, 'apple', 'durga', 'shyam'}

type(set)

set

# Examplpe -->

# sms sending application:
#     sms for unique numbers in any order

for x in set:
    print(x)

-30
10.5
20
apple
shyam
10
durga

set.append(50)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[48], line 1
----> 1 set.append(50)

AttributeError: 'set' object has no attribute 'append'

set.add(50)

set

{-30, 10, 10.5, 20, 50, 'apple', 'durga', 'shyam'}

set.remove('durga')
set

{-30, 10, 10.5, 20, 50, 'apple', 'shyam'}

# Difference b/w List and Set :-

# List :-
#     1. Duplicates Allowed
#     2. Order preserved
#     3. Indexing and Slicing Concepts are applicable
#     4. []

# Set :-
#     1. Duplicates Not Allowed
#     2. Order not preserved
#     3. Indexing and Slicing Concepts are not applicable 
#     4. {}

# # Note :- How to Create Empty Set

s = {}
print(type(s)) # beacuse dict is most common used

s = set()
print(type(s)) # set
print(len(s)) # 0
print(s) # set()

<class 'dict'>
<class 'set'>
0
set()

# # Frozenset :-

# It is exactly same as set except that it is immutable.

s = {10,20,30,'durga',10.5,True,10,False}
s

{10, 10.5, 20, 30, False, True, 'durga'}

type(s)

set

fs = frozenset(s)
fs

frozenset({10, 10.5, 20, 30, False, True, 'durga'})

type(fs)

frozenset

fs.add(50)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[7], line 1
----> 1 fs.add(50)

AttributeError: 'frozenset' object has no attribute 'add'

fs.remove(10)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[8], line 1
----> 1 fs.remove(10)

AttributeError: 'frozenset' object has no attribute 'remove'

# # dict Data Type :-

# list ==> [10, 20, 30, 40]
# tuple ==> (10, 20, 30, 40)
# set ==> {10, 20, 30, 40}
# frozenset ==> frozenset({10, 20, 30, 40})

# All these data types can hold individual values.
# key-value pairs are
# rollno --> name
# name --> mail id

# dict --> dictionary

# [] --> list
# () --> tuple
# {} --> set
# {} --> dict

d = {100:'durga', 200:'ravi', 300:'shiva'}

print(d)
print(type(d))

{100: 'durga', 200: 'ravi', 300: 'shiva'}
<class 'dict'>

d = {}

print(type(d))

<class 'dict'>

d = {}

print(d)

{}

# d[key] = value

d[100] = 'sunny'
d[200] = 'bunny'
d[300] = 'chinny'

print(d)

{100: 'sunny', 200: 'bunny', 300: 'chinny'}

print(d[100])

sunny

# Properties of dictionary DataType :-

    # 1. Order is not preserved

    # 2. Indexing and Slicing concepts are not applicable

    # 3. For keys and values we can use any data type no restrictions.

    # 4. keys and values can be hetrogeneous

    # 5. duplicate keys are not allowed but values can be duplicate

    # 6. If we are trying to add entry with duplicate key, then old value will be replaced with new value

    # 7. Mutable

d = {100:'ravi', 'durga':200}
print(d)

{100: 'ravi', 'durga': 200}

d = {a:'durga', b:'abhi'}

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[17], line 1
----> 1 d = {a:'durga', b:'abhi'}

NameError: name 'a' is not defined

a = 100
b = 200
d = {a:'durga', b:'abhi'}

print(d)

{100: 'durga', 200: 'abhi'}

d = {100:'durga', 200:'ravi'}

# keys: 100, 200
# values: 'durga', 'rqavi'

d = {100:'ravi', 200:'durga', 100:'durga', 200:'ravi'}

print(d)

{100: 'durga', 200: 'ravi'}

d = {100:'durga'}

print(d)

d[100] = 'ravi'

print(d)

{100: 'durga'}
{100: 'ravi'}

d = {100:['durga', 'ravi', 'shiva']}

print(d)

{100: ['durga', 'ravi', 'shiva']}

d = {100:'abc', '100':'xyz'}

print(d)

{100: 'abc', '100': 'xyz'}

# # Range Data Type :-

# range means sequence of values

# 0 to 9
# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

r = range(10)

print(r)
print(type(r))

range(0, 10)
<class 'range'>

for x in r:
    print(x)

0
1
2
3
4
5
6
7
8
9

# Properties of Range Data Type :-

    # Sequence

    # form-1:
        # range(n) ==> 0 to n-1 values can be represented

    # form-2:
        # range(begin, end) ==> from begin value to end-1

    # form-3:
        # range(begin, end, increment/decrement value) ==> from begin value to end-1 and increment/decrement

    # Indexing and slicing also applicable

    # Immutable

r = range(2,8)
for x in r:
    print(x)

2
3
4
5
6
7

r = range(1,11)
for x in r:
    print(x)

1
2
3
4
5
6
7
8
9
10

r = range(1,11,2)
for x in r:
    print(x)

1
3
5
7
9

r = range(11,1,-2)
for x in r:
    print(x)

11
9
7
5
3

r = range(1,11,3)
for x in r:
    print(x)

1
4
7
10

l = []
r = range(0,101,5)
for x in r:
    l.append(x)
print(l)

[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]

r = range(1,11,-1)
for x in r:
    print(x)

r = range(10)

print(r)
print(r[0])

range(0, 10)
0

print(r[2])

2

print(r[5])

5

print(r[-1])

9

print(r[2:5])

range(2, 5)

print(r[2:8:2])

range(2, 8, 2)

r[1] = 7777

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[74], line 1
----> 1 r[1] = 7777

TypeError: 'range' object does not support item assignment

# # bytes Data Type :-

# If we want tot represent a group of values within the range 0 to 255

# Properties of byte Data Type :-

# 1. Indexing and slicing applicable

# 2. Values should be in range 0 to 255

# 3. Immutable

# 4. b = bytes()

l = [10, 20, 30, 40]

b = bytes(l)

print(type(b))
print(b)

<class 'bytes'>
b'\n\x14\x1e('

l = [10, 20, 30, 40, 256]

b = bytes(l)

print(type(b))
print(b)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[79], line 3
      1 l = [10, 20, 30, 40, 256]
----> 3 b = bytes(l)
      5 print(type(b))
      6 print(b)

ValueError: bytes must be in range(0, 256)

print(b[0])

10

print(b[2])

30

print(b[-1])

40

for x in bytes[1:3]:
    print(x)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[84], line 1
----> 1 for x in bytes[1:3]:
      2     print(x)

TypeError: type 'bytes' is not subscriptable

for x in b[1:3]:
    print(x)

20
30

l = [10, 20, 30, 40]

b = bytes(l)

b[0] = 777

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[86], line 5
      1 l = [10, 20, 30, 40]
      3 b = bytes(l)
----> 5 b[0] = 777

TypeError: 'bytes' object does not support item assignment

# list --> mutable
# tuple --> immutable
# set --> mutable
# frozenset --> immutable
# dict --> mutable
# range --> immutable
# bytes --> immutable
# bytearray --> mutable

# # bytearray Data Type :-

# It is exactly same as bytes except that it is mutable.

l = [10, 20, 30, 40]

b = bytearray(l)

print(type(b))

<class 'bytearray'>

l = [10, 20, 30, 40, 256]

b = bytearray(l)

print(type(b))

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[93], line 3
      1 l = [10, 20, 30, 40, 256]
----> 3 b = bytearray(l)
      5 print(type(b))

ValueError: byte must be in range(0, 256)

l = [10, 20, 30, 40]

b = bytearray(l)

b[0] = 15

for x in b:
    print(x)

15
20
30
40

# # Data Types :-

# int flaot complex bool str
# list tuple
# set frozenset
# dict
# range
# bytes bytearray

# 1. In general bytes and bytearray types can be used to represent binary information like images, video files etc.

# 2. Long data type avaliable in Python2x but not in Python3x long values also can be represented as int type only

# 3. char data type 'a' as str type

# # None Data Type :-

# None means nothing or no value associated.

# If the value is not available, to handle such type of requirements None (null in Java)

# None --> no value associated

# None is also an object in Python

x = None
print(x)
print(id(x))
print(type(x))

None
140731371719440
<class 'NoneType'>

def f1():
    return 10

r = f1()
print(r)

10

def f1():
    print('hello')

r = f1()
print(r)

hello
None

# Only one None value will be created in python

a = None
b = None
c = None
def f1():
    pass
r = f1()

print(a)
print(id(a))
print(type(a))

print(b)
print(id(b))
print(type(b))

print(c)
print(id(c))
print(type(c))

print(r)
print(id(r))
print(type(r))

None
140731371719440
<class 'NoneType'>
None
140731371719440
<class 'NoneType'>
None
140731371719440
<class 'NoneType'>
None
140731371719440
<class 'NoneType'>

# # Escape Characters :-

# The characters associated with some special meaning

# \n --> New Line
# \t --. Horizontal Tab
# \r --> Carriage Return
# \b --> Backspace
# \f --. Form Feed
# \v --> Vertical Tab
# \' --> Single Quote
# \" --> Double Quote
# \\ --> Backslash Symbol
# etc

s = 'durga\tsoft'
print(s)

durga	soft

s = 'durga\nsoft'
print(s)

durga
soft

s = 'durga\rtsoft'
print(s)

tsoft

s = 'durga\bsoft'
print(s)

durgsoft

s = 'durga\fsoft'
print(s)

durga
soft

s = 'durga\vsoft'
print(s)

durga
soft

s = 'durga\'sof\'t'
print(s)

durga'sof't

s = 'durga\"sof\"t'
print(s)

durga"sof"t

s = 'C:\\Python\\Practice'

# # Comments :-

# Single Line Comment:

# This is code
s = 'pulkit' # code output: 'pulkit'

# Multi-Line Comment:
    # There is no special symbol for multiline comments

'''
This is
Multi-Line
Comment
''' # This is Documentation String but not Comment

"""
This is
Multi-Line
Comment
""" # This is Documentation String but not Comment

s = 'pulkit'

# Triple Quotes can be used for:-

    # 1. To define multiline string literals

    # 2. To use ' or " as symbols

    # 3. To define docstring

# # Constants :-

# Constants concept not applicable in Python

# MAX_VALUE = 10 # it is constant doesn't change its value

# max_value = 10

MAX_VALUE = 10
print(type(MAX_VALUE))

<class 'int'>

# set --> unique elements(no duplicates)
        # order is not important

s = {10, 20, 30, 40}
s.add(50)
print(s)

{40, 10, 50, 20, 30}

# unique elements(no duplicates)
# order is not important
# frozenset

s = {10, 20, 30, 40}
fs = frozenset(s)
fs.add(50)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[4], line 7
      5 s = {10, 20, 30, 40}
      6 fs = frozenset(s)
----> 7 fs.add(50)

AttributeError: 'frozenset' object has no attribute 'add'

# bytes and bytearray

# 0 to 255
# bytes --> immutable
# bytearray --> mutable

# images, video files and audio files etc

l = [10, 20, 30, 40]
b = bytes(l)
for x in b:
    print(x)

10
20
30
40

b[0] = 50

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[8], line 1
----> 1 b[0] = 50

TypeError: 'bytes' object does not support item assignment

l = [10, 20, 30, 40]
b = bytearray(l)
for x in b:
    print(x)

10
20
30
40

b[0] = 50

for x in b:
    print(x)

50
20
30
40

print('# this is comment')

# this is comment

# # Operators :-

# Telephone Operator
# Camera Operator

# # Types of Operators:-

    # 1. Arithmetic Operators

    # 2. Relational Operators

    # 3. Logical Operators

    # 4. Bitwise Operators

    # 5. Assignment Operators

    # 6. Special Operators

# 1. Arithmetic Operators :-

# + --> Addition
# - --> Subtraction
# * --> Multiplication
# / --> Division
# % --> Modulo Operator

# // --> Floor Division Operator
# ** --> Exponent Operator or Power Operator

10+2

12

10-2

8

10*2

20

10%2

0

# # Note:-
    # The result of '/' division operator is always float type

    # // result is either int type or float type
        # If both arguments are int type result is int type only
        # If atleast one argument is float type result is float type

10/2

5.0

10//2

5

23/6

3.8333333333333335

23//6

3

1.2//2

0.0

# 1.56 ->

# floor int value ==> 1
# floor float value ==> 1.0
# ceil int value ==> 2
# ceil float value ==> 2.0

10.0/2

5.0

10.0//2

5.0

10/3

3.3333333333333335

10//3

3

10.0/3

3.3333333333333335

10.0//3

3.0

# * --> multiplication
# ** --> exponential or power

10**3   # 10 * 10 * 10

1000

3**3    # 3 * 3 * 3

27

3***3

  Cell In[85], line 1
    3***3
       ^
SyntaxError: invalid syntax

3.0**3

27.0

3**3*2

54

10**-3

0.001

10**2.8

630.957344480193

3//2

1

# + and * :-

# + operator applicable for str type also
# concatenation operator

s = 'durga' + 'soft'
print(s)

durgasoft

'durga' + str(10)

'durga10'

int('durga')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[97], line 1
----> 1 int('durga')

ValueError: invalid literal for int() with base 10: 'durga'

'durga' + 10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[99], line 1
----> 1 'durga' + 10

TypeError: can only concatenate str (not "int") to str

# Problem with Value ValueError

# Problem with Type TypeError

'durga' * 3

'durgadurgadurga'

'durga' * 'durga'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[102], line 1
----> 1 'durga' * 'durga'

TypeError: can't multiply sequence by non-int of type 'str'

'durga' * int('10')

'durgadurgadurgadurgadurgadurgadurgadurgadurgadurga'

# + --> both arguments should be str type or int type
# * --> one arg str and one arg int

'durga' * 10.0

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[109], line 1
----> 1 'durga' * 10.0

TypeError: can't multiply sequence by non-int of type 'float'

10/0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[110], line 1
----> 1 10/0

ZeroDivisionError: division by zero

10.0/0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[111], line 1
----> 1 10.0/0

ZeroDivisionError: float division by zero

'abc' * 0

''

# 2. Relational Operators :-

# <, <=, >, >=

a = 10
b = 20

a < b

True

a <= b

True

a > b

False

a >= b

False

# string values also comparison is bsaed on unicode value/ascii value

# a --> 97
# b --> 98
# c --> 99

# A --> 65
# B --> 66
# C --> 67

a = 'durga'
b = 'ravi'

a < b

True

a <= b

True

a > b

False

a >= b

False

a = 'durga'
b = 'Durga'

a < b

False

a <= b

False

a > b

True

a >= b

True

ord('d')

100

ord('D')

68

ord('a') * ord('b')

9506

ord('a') + ord('b')

195

# from char find ascii value
    # ord()

# from ascii value to char value
    # chr()

# char --> ord()
# ascii --> chr()

chr(99)

'c'

chr(10)

'\n'

chr(72) + chr(99)

'Hc'

# for boolean types

# True --> 1
# Fasle -->

a = True
b = False

a > b

True

a >= b

True

a < b

False

a <= b

False

'durga' < 10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[151], line 1
----> 1 'durga' < 10

TypeError: '<' not supported between instances of 'str' and 'int'

a = True
b = 10

a > b

False

a < b

True

2**2 < 5

True

2**2 > 5

False

'a' > '297'

True

ord('a')

97

ord('2')

50

ord('a') > ord('2')

True

10 < 20

True

10 < 20 < 30

True

10 < 20 < 30 < 40

True

10 < 20 < 30 < 40 > 50

False

# Chaning of Relational Operators:-
    # If all comparison returns True then the result is True.

    # If atleast one comparison returns False then the result is False.

# Equality Operators :-

# ==    and     !=

# always meant for content comparosion

10 == 20

False

10 == 10

True

10.5 == 10

False

10.0 == 10

True

'durga' == 'ravi'

False

'durga' == 10

False

True == False

False

True == 1

True

ord('d')

100

'd' == 100

False

ord('d') == 100

True

# == --> operator for content comparosion
# = --> means assignment

True == 1.0

True

ord('a') == 97

True

# Chaning of Equality Operators:-
    # If all comparison returns True then the result is True.

    # If atleast one comparison returns False then the result is False.

10 == 20 == 30 == 40

False

10 == 10.0 == 10 == 10.0

True

1 == 1.0 == True == 1.0

True

# == operator and is operator

# == operator meant for content comparosion
# is operator meant for reference comparosion(address comparison)

# is operator returns True if both refrences are pointing to the same object address.

l1 = [10, 20, 30, 40]
l2 = [10, 20, 30, 40]

print(id(l1))
print(id(l2))

print(l1 is l2)
print(l1 == l2)

1444155477056
1444155379712
False
True

l1 = [10, 20, 30, 40]
l2 = l1

print(id(l1))
print(id(l2))

print(l1 is l2)
print(l1 == l2)

1444155476352
1444155476352
True
True

# 3. Logical Operators :-

# and
# or
# not

# For boolean Types :-

    # and --> If both arguments are True then only result is True

    # or --> If atleast one argument is True then result is True

    # not --> complement

True and True

True

True and False

False

False and True

False

False and False

False

not True

False

not False

True

True or True

True

True or False

True

False or True

True

False or False

False

# For non-Boolean Types :-

    # zero consider as False
    # non-zero consider as True

    # empty string, set, list, tuple etc considered as False
    # non-empty considered as True

# For non-Boolean Types we are not getting True or False.

# and Operator :-

# x and y ->
    # if x evalutes to True then the result is y

    # if x evalutes to False then the result is x

10 and 20

20

0 and 10

0

'' and 10

''

'as' and 10

10

# or Operator :-

# x or y ->
    # If x evaluates to True then the result is x

    # If x evaluates to False then the result is y

10 or 20

10

0 or 10

10

10 or 0

10

'' or 'durga'

'durga'

'durga' or ''

'soft'

0 or 0

0

not 10

False

not ''

True

not 0

True

not 'durga'

False

# 4. Bitwise Operators :-

# & --> AND
# | --> OR
# ^ --> X-OR
# ~ --> Bitwise Complement Operator
# << --> Left Shift Operator
# >> --> Right Shift Operator

# Applicable only for:-
    # int type and boolean type

10 & 11

10

True & False

False

10.5 & 11.6

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[4], line 1
----> 1 10.5 & 11.6

TypeError: unsupported operand type(s) for &: 'float' and 'float'

# & --> If both bits are 1 then result is 1

# | --> If atleast one bit is 1 then result is 1

# ^ --> If both bits are different then result is 1
        # if both bits are same then result is 0

a = 4  # 4 --> 1 0 0
b = 5  # 5 --> 1 0 1

a & b  #       1 0 0

4

a = 4  # 4 --> 1 0 0
b = 5  # 5 --> 1 0 1

a | b  #       1 0 1

5

a = 4  # 4 --> 1 0 0
b = 5  # 5 --> 1 0 1

a ^ b  #       0 0 1

1

# Bitwise Complement Operator(~) :-

~4

-5

~9

-10

~-5

4

~-20

19

# 32 bits

# The most significant bit(MSB) acts as sign bit
    # 0 means +ve number
    # 1 means -ve number

# positive numbers will be represented directly in the memory

# But negative numbers will be represented indirectly in the memory in 2's complement form

# 2's complement form = 1's complement form+1
# 1's complement form = intrchange 0s and 1s

#  4 = 0000000000.....000000100
# ~4 = 1111111111.....111111011 ==> -5

# Shift Operators :-

# << and >>

# << --> Left Shift
# >> --> Right Shift

# << --> Left Shift :-

# extra cells are always filled with zero

10 << 2

#   10 --> 00000000000....0000000001010
# 10<< -->     000000000....0000000101000

40

4 << 2

#   4 --> 00000000000....0000000000100
# 4<< -->     000000000....0000000010000

16

# >> --> Right Shift :-

# extra cells are always filled with sign bit
    # +ve number zero(0)
    # -ve number one(1)

10 >> 2

#   10 -->   00000000000....0000000001010
# 10>> --> 00000000000000000....000000010

2

4 >> 2

#   4 -->   00000000000....0000000000100
# 4<< --> 00000000000000000....000000001

1

-10 >> 2

#       10       -->      00000000000....0000000001010
# 1's complement -->      11111111111....1111111110101
#                                                    1
# 2's complement -->      11111111111....1111111110110

#      -10       -->      11111111111....1111111110110

#     -10>>      -->    111111111111111....11111111101  # -ve as first value is 1
# 2's complement -->    000000000000000....00000000010
#                                                    1
#                -->    000000000000000....00000000011

# Value is -ve so ans is -3

-3

10 >> -3

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[38], line 1
----> 1 10 >> -3

ValueError: negative shift count

True & True

True

True | True

True

True ^ False

True

False ^ True

True

~True

-2

~False

-1

True >> 2

0

False >> 2

0

True << 2

4

False << 2

0

False << 4

0

False << 4

0

# 5. Assignment Operators :-

# assignment combined with some other operators: compound assignment operator

# +=
# -=
# *=
# /=
# %=
# //=
# **=
# &=
# |=
# ^=
# >>=
# <<=

x = 10
print(x)
x += 20
print(x)

10
30

x = 4
print(x)
x **= 2
print(x)

4
16

x = 4
print(x)
x &= 5
print(x)

4
4

x = 10
print(x)
x++
print(x)

  Cell In[36], line 3
    x++
       ^
SyntaxError: invalid syntax

x = 10
print(x)
++x
print(x)

10
10

x = 10
print(x)
++++x
print(x)

10
10

x = 10
print(x)
--x
print(x)

10
10

x = 10
print(x)
---x
print(x)

10
10

x = 10
print(x)
x =+ x
print(x)

10
10

x = 10
print(x)
x =+ x
print(x)
x = x
print(x)

10
10
10

x = 10
print(x)
x =-- x
print(x)

10
10

x = 10
print(x)
x =--- x
print(x)

10
-10

# # How to handle increment and decrement in python

x = 10
print(x)

x = x+1
print(x)

10
11

x = 10
print(x)

x += 1
print(x)

10
11

x = 10
print(x)

x = x-1
print(x)

10
9

x = 10
print(x)

x -= 1
print(x)

10
9

# Ternary Operator or Conditional Operator :-

# Unary Operators :-

# ~x
# not x

# Binary Operators :-

# a+b
# a*b

# Ternary Operator or Conditional Operator :-

# a,b = 10,20
# x = 30 if a<b else 40
    # x = first value if condition else second value

a,b = 10,20
x = 30 if a<b else 40
print(x)

30

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))

min = a if a < b else b
print('Minimum Value:', min)

Minimum Value: 2

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))
c = int(input('Enter Third Number: '))

min = a if a<b and a<c else b if b<c else c
print('Minimum Value:', min)

Minimum Value: 12

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))
c = int(input('Enter Third Number: '))

min = a if a>b and a>c else b if b>c else c
print('Maximum Value:', min)

Minimum Value: 99

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))

s1 = 'Both Number are Equal'
s2 = 'First Number is greater than Second Number'
s3 = 'First NUmber is less than Second Number'

result = s1 if a==b else s2 if a>b else s3
print(result)

Both Number are Equal

max(10, 20, 50, 90, 30, 500, 450, 160, 420, 390)

500

# 6. Special Operators :-

# Special Operators :-
    # 1. Identity Operator

    # 2. Membership Operator

# 1. Identity Operator

# is
# is not

# Example:
    # r1 is r2 retruns True if both refrences are pointing to the same address
    # r1 is not r2 retruns True if both refrences are not pointing to the same object

a = 10
b = 10

print(id(a))
print(id(b))

print(a is b)
print(a is not b)

140731373110344
140731373110344
True
False

a = 10
b = 20

print(id(a))
print(id(b))

print(a is b)
print(a is not b)

140731373110344
140731373110664
False
True

a = [10,20,30,40]
b = [10,20,30,40]

print(id(a))
print(id(b))

print(a is b)
print(a == b)
print(a is not b)

1772942460224
1772942011136
False
True
True

a = [10,20,30,40]
b = a

print(id(a))
print(id(b))

print(a is b)
print(a == b)
print(a is not b)

1772948496768
1772948496768
True
True
False

# 2. Membership Operator :-

# given object present in the given collection or not

# collection can be --> string, list, tuple, set, dict etc

# obj in collection ==> if obj is member of collection returns True

# not in collection ==> if obj is not member of collection returns True

x = 'hello learning python is very easy!!!'

'h' in x

True

'd' in x

False

'd' not in x

True

'python' in x

True

'python' not in x

False

list = ['sunny', 'bunny', 'chinny', 'vinny']

'bunny' in list

True

'buuny' in list

False

10+20*3

70

# Python Operator Precedence :-

# ()
# **
# ~,-(unary minus)
# *, /, %, //
# +, -
# <<, >>
# &
# ^
# |
# >, >=, <, <=, ++, !=
# =, +=, -=, *=, ...
# is, is not
# in, in not
# not
# and
# or

a = 30
b = 20
c = 10
d = 5

(a+b)*c/d

100.0

(a+b)*(c/d)

100.0

a+(b*c)/d

70.0

# # # Mathematical Functions by using Math Module :-

# Library Contains ---> a group of packages

# Package Contains ---> a group of modules

# Module Contains ---> a group of functions, variables, classes etc

# Module name: durgamath
    # import durgamath

# short alias name

# import durgamath as dm

# from durgamath as dm
# print(dm.PI)
# print(dm.name)
# dm.add(10,20)
# dm.multiply(10,20)
# s = dm.Student()
# s.activity()

# # Note :-
    # Once we defined alias name, we cannot use original name.

# from durgamath as dm
# print(durgamath.PI)
# print(dm.name)
# dm.add(10,20)
# dm.multiply(10,20)
# s = dm.Student()
# s.activity()

# It will show error

# Access memebers directly without module name???

# from durgamath import PI

# from durgamath import PI, name
# print(PI)
# print(name)
# add(10,20)
# multiply(10,20)
# s = Student()
# s.activity()

# In this only PI and name are available

# from durgamath import *
# print(PI)
# print(name)
# add(10,20)
# multiply(10,20)
# s = Student()
# s.activity()

# Alias name for the members :-

# from durgamath import add as a
# a(100,200)

import math

math.sqrt(16)

4.0

math.pi

3.141592653589793

from math import *

sqrt(16)

4.0

pi

3.141592653589793

import math as m

m.sqrt(16)

4.0

m.pi

3.141592653589793

import math

print(dir(math))

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

from math import *

print('PI =',pi)
print('E =',e)
print(ceil(10.1))
print(floor(10.1))

PI = 3.141592653589793
E = 2.718281828459045
11
10

from random import randint

randint(0,9)

5

randint(0,9)

2

from random import *

randint(0,9)

3

# # Input and Output Statements :-

# Input Statements :-

# To read dynamic input from the keyboard :-
    # 1. raw_input()

    # 2. input()

# 1. raw_input() :-

# x = raw_input('Enter some value:')
# print(type(x)) # str type only
# i = int(x)
# Typecasting is required

# 2. input() :-

# x = input('Enter some value:')
# print(type(x)) # the result need not be str type
# Typecasting is not required

# This story is not appl only for Python-2 but not for Python-3

# In Python-3, we have only input() function but not raw_input() function.

# Python-3 input() function ==> Python-2 raw_input() function

# In Python-3 input() function always returns str type only.
# We have to perform typcasting.

# 100 objects ==> minimum 90% of objects are string type only
# 10% requirement ==> typecasting functions are there

x = input('Enter some value: ')
print(type(x))

<class 'str'>

x = int(input('Enter some value: '))
print(type(x))

<class 'int'>

# # String to Other Types :-

# Type casting functions are required

# Type casting ==> Type Conversion

# str --> int type      ==> int(str)
# str --> float type    ==> float(str)
# str --> boolean type  ==> boolean(str)
# str --> complex type  ==> complex(str)

x = input('Enter some value: ')
i = int(x)
print(type(i))

<class 'int'>

x = input('Enter some value: ')
i = float(x)
print(type(i))

<class 'float'>

x = input('Enter some value: ')
i = bool(x)
print(type(i))

<class 'bool'>

x = input('Enter some value: ')
i = complex(x)
print(type(i))

<class 'complex'>

x = input('Enter First Number: ')
y = input('Enter Second Number: ')

x = int(x)
y = int(y)

print('Sum is:', x+y)

Sum is: 6924

x = int(input('Enter First Number: '))
y = int(input('Enter Second Number: '))

print('Sum is:', x+y)

Sum is: 11

eno = int(input('Enter Employee Number: '))
ename = input('Enter Employee Name: ')
esal = float(input('Enter Employee Salary: '))
eaddr = input('Enter Employee Address: ')
married = bool(input('Employee Married?[True|False]: '))

print('Please Confirm your Information:')
print('Employee Number: ', eno)
print('Employee Name: ', ename)
print('Employee Salary: ', esal)
print('Employee Address: ', eaddr)
print('Employee Married: ', married)

Please Confirm your Information:
Employee Number:  784
Employee Name:  ankd
Employee Salary:  4654.0
Employee Address:  acef
Employee Married:  True

# eval('str')
# eval('10')    --> int
# eval('10.5')  --> float
# eval('True')  --> boolean
# eval('False') --> boolean

eno = int(input('Enter Employee Number: '))
ename = input('Enter Employee Name: ')
esal = float(input('Enter Employee Salary: '))
eaddr = input('Enter Employee Address: ')
married = eval(input('Employee Married?[True|False]: '))

print('Please Confirm your Information:')
print('Employee Number: ', eno)
print('Employee Name: ', ename)
print('Employee Salary: ', esal)
print('Employee Address: ', eaddr)
print('Employee Married: ', married)

Please Confirm your Information:
Employee Number:  46
Employee Name:  dwf
Employee Salary:  45.0
Employee Address:  ad
Employee Married:  False

# # eval() :-

# eval() functin take string as argument and evaluates the result.

x = eval('10+20+30')
print(x)
print(type(x))

60
<class 'int'>

x = int('10+20+30')
print(x)
print(type(x))

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[36], line 1
----> 1 x = int('10+20+30')
      2 print(x)
      3 print(type(x))

ValueError: invalid literal for int() with base 10: '10+20+30'

x = eval(input('Enter some Value:'))
print(x)
print(type(x))

(10, 10, 51)
<class 'tuple'>

x = eval('true')
print(x)
print(type(x))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[38], line 1
----> 1 x = eval('true')
      2 print(x)
      3 print(type(x))

File <string>:1

NameError: name 'true' is not defined

x = eval('True')
print(x)
print(type(x))

True
<class 'bool'>

x = eval(input('Enter some Value:'))
print(x)
print(type(x))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[40], line 1
----> 1 x = eval(input('Enter some Value:'))
      2 print(x)
      3 print(type(x))

File <string>:1

NameError: name 'true' is not defined

# eval() is always taking string argument only, but that string should represent non-string value internally.

x = eval('durga')
print(x)
print(type(x))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[42], line 1
----> 1 x = eval('durga')
      2 print(x)
      3 print(type(x))

File <string>:1

NameError: name 'durga' is not defined

x = eval('10')
print(x)
print(type(x))

10
<class 'int'>

# How to read multiple values from the keyboard in a single line :-

# '10 20 30' ==> a single string which contains int values with space separator

# ['10', '20', '30'] ==> list

s = '10 20 30'

l = s.split()
print(l)

['10', '20', '30']

# string values to int type ==> int()

s = '10 20 30'

l = s.split()
print(l)

['10', '20', '30']

a, b, c = [10, 20, 30]  # unpacking

print(a, b, c)

10 20 30

s = input('Enter two Numbers:')
print(s)

l = s.split()
print(l)

45 65
['45', '65']

l = input('Enter two Numbers:').split()
print(l)

['65', '46']

a, b = input('Enter two Numbers:').split()
print(a)
print(b)

print(type(a))
print(type(b))

46
654
<class 'str'>
<class 'str'>

# for each string present in this list, convert into int value

# list comprehension

a, b = [int(x) for x in input('Enter two Numbers:').split()]

print(a)
print(b)

print(type(a))
print(type(b))

6546
656
<class 'int'>
<class 'int'>

a, b = [int(x) for x in input('Enter two Numbers:').split()]

print('Product of two numbers:', a*b)

Product of two numbers: 3936

a, b = [int(x) for x in input('Enter two Numbers:').split(',')]

print('Product of two numbers:', a*b)

Product of two numbers: 1080

a, b, c = [float(x) for x in input('Enter two Numbers:').split('-')]

print('Sum of Numbers:', a+b+c)

Sum of Numbers: 15.0

# Comand Line Arguments :-

# The arguments which are passing from the command prompt

# cmd line arguments are always str type only

# python test.py    10 20 30

# sys module

# argv --> list
    # contains 4 values
    # test.py 10 20 30

# argv[0] --> test.py
# argv[1] --> 10
# argv[2] --> 20
# argv[3] --> 30

from sys import argv\

print(len(argv))
print(argv)
print(type(argv))

2
['c:\\Users\\pulki\\anaconda3\\envs\\Personal\\Lib\\site-packages\\ipykernel_launcher.py', '--f=c:\\Users\\pulki\\AppData\\Roaming\\jupyter\\runtime\\kernel-v2-15792Rm05Jqyd3e23.json']
<class 'list'>

print(argv[0])

c:\Users\pulki\anaconda3\envs\Personal\Lib\site-packages\ipykernel_launcher.py

for x in argv:
    print(x)

c:\Users\pulki\anaconda3\envs\Personal\Lib\site-packages\ipykernel_launcher.py
--f=c:\Users\pulki\AppData\Roaming\jupyter\runtime\kernel-v2-15792Rm05Jqyd3e23.json

# Input --> python test.py 10 20 30

# from sys import argv

# x = argv[1:]  # ['10', '20', '30']
# sum = 0

# for x1 in x:
    # n = int(x1)
    # sum = sum + n # sum+=n

# print('The Sum:', sum)

# 1. space is the separator
    # we should use ""

# 2. always str type
    # typecasting

# 3. out of range index
    # IndexError

# Language Fundamentals
# Operators and Assignments
# Input and Output Statements
    # Input Statements
        # input()
        # command line arguments

    # Output Statements

# Output Statements :-

# Form-1 :-
    # print()

# To print new line character(\n)

print()

print('Hi')

Hi

print('\n')

# Form-2 :-
    # print('string')

# In the string we can use escape characters also

# String repeation Operator *
    # One argument must be string and other argument must be int
    # 'durga' * 3
    # 3 * 'durga'

# String concatenation Operator also +
    # Both arguments must be strings type:
    # 'durga' + 'soft'

print('DURGA\tSOFTWARE\tSOLUTIONS')

DURGA	SOFTWARE	SOLUTIONS

print('DURGA\nSOFTWARE\nSOLUTIONS')

DURGA
SOFTWARE
SOLUTIONS

print('DURGA' * 3)

DURGADURGADURGA

print('DURGA' + 'SOFT')

DURGASOFT

print(3 + 'durga' + 3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[17], line 1
----> 1 print(3 + 'durga' + 3)

TypeError: unsupported operand type(s) for +: 'int' and 'str'

print(3 * 'DURGA' + 'SOFT')

DURGADURGADURGASOFT

print('DURGA' + 'SOFT')
print('DURGA' , 'SOFT')

DURGASOFT
DURGA SOFT

# Form-3 :-
    # print() with sep attribute

# default value for sep attribute: space

# Other than space if you want any other, then we should use "sep" attribute
    # separator

a,b,c = 10,20,30
print('The Values are:', a,b,c)

The Values are: 10 20 30

name = 'DURGA'
gf = 'SUNNY'
print('Hello', name, 'Your Girl Friend', gf, 'is too good human being')

Hello DURGA Your Girl Friend SUNNY is too good human being

a,b,c = 10,20,30
print(a,b,c, sep='-')

10-20-30

a,b,c = 10,20,30
print(a,b,c, sep='')

102030

# Form-4 :-
    # print() with end attribute

# Other than \n if you want any other character: end attribute

# default value for end attribute: \n

print('Hello')
print('durga')
print('soft')

Hello
durga
soft

print('Hello', end='*')
print('durga', end=' ')
print('soft')

Hello*durga soft

a,b,c = 10,20,30

print(a,b,c, sep='-', end='###')
print(a,b,c, sep='-')
print('durga')

10-20-30###10-20-30
durga

# Form-5 :-
    # print(object)

print(10)

10

print(True)

True

print([10,20,30])

[10, 20, 30]

print((10,20,30))

(10, 20, 30)

# Form-6 :-
    # print(formatted string)

# %i --> int
# %d --> int
# %f --> float
# %s --> string type

# print('formatted string' %(variable list))

a = 10

print('a value is %i' %a)

a value is 10

a = 10
b = 20
c = 30

print('a value is %i b value is %i c value is %i' %(a,b,c))

a value is 10 b value is 20 c value is 30

a = 10
b = 20
c = 30

print('a value is %d b value is %d c value is %d' %(a,b,c))

a value is 10 b value is 20 c value is 30

name = 'durga'
l = [10,20,30,40]

print('hello %s... The List of items are %s' %(name, l))

hello durga... The List of items are [10, 20, 30, 40]

# Form-7 :-
    # print() with {}

# {} --> Replacement Operator

name = 'Durga'
salary = 10000
gf = 'Sunny'

print(f'Hello {name}, your salary is {salary}, and your Friend is {gf}')

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hello {x}, your salary is {y}, and your Friend is {z}'.format(x=name, y=salary, z=gf))

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hello {0}, your salary is {1}, and your Friend is {2}'.format(name, salary, gf))

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hello {0}, your salary is {1}, and your Friend is {2}'.format(salary, gf, name))

Hello 10000, your salary is Sunny, and your Friend is Durga

print('Hello {}, your salary is {}, and your Friend is {}'.format(name, salary, gf))

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hi {0} sal is {1}'.format(0='AA', 1=10000))

  Cell In[64], line 1
    print('Hi {0} sal is {1}'.format(0='AA', 1=10000))
                                     ^
SyntaxError: expression cannot contain assignment, perhaps you meant "=="?

# Language Fundamentals
# Operators and Assignments
# Input and Output Statements

# # Flow Control :-

# # Flow Controls Statements :-

    # Conditional Statements or Selection Statements :-
        # if
        # if-else
        # if-elif-else
        # if-elif

    # Iterative Statements (Loops) :-
        # for
        # while

    # Transfer Staements :-
        # break
        # continue

# pass
# del

# 1. Conditional Statements :-

# 1. if :-

# if condition:
    # body

# Indentation is important in Python

# if condition:
    # statement
    # statement
    # statement
# statements
# statements

name = input('Enter Your Name:')

if name == 'durga':
    print('Hello Durga!')
print('How are you')

Hello Durga!
How are you

# 2. if-else :-

# if condition:
    # action-1
# else:
    # action-2

name = input('Enter Your Name:')

if name == 'durga':
    print('Hello Durga!')
else:
    print('Hello Guest!')

print('How are you')

Hello Guest!
How are you

# 3. if-elif-else :-

# if condition-1:
    # action-1
# elif condition-2:
    # action-2
# elif condition-3:
    # action-3
# elif condition-4:
    # action-4
# ....
# else:
    # default Action

brand = input('Enter Your Favourite Brand:')

if brand == 'RC':
    print('RC is a great brand')
elif brand == 'KF':
    print('KF is a great brand')
elif brand == 'KO':
    print('KO is a great brand')
elif brand == 'FO':
    print('FO is a great brand')
else:
    print('I dont know that brand')

I dont know that brand

# 4. if-elif :-

# if condition-1:
    # action-1
# elif condition-2:
    # action-2
# elif condition-3:
    # action-3
# elif condition-4:
    # action-4

brand = input('Enter Your Favourite Brand:')

if brand == 'RC':
    print('RC is a great brand')
elif brand == 'KF':
    print('KF is a great brand')
elif brand == 'KO':
    print('KO is a great brand')
elif brand == 'FO':
    print('FO is a great brand')

print('I don\'t know brand')

I don't know brand

n1 = int(input('Enter First Number: '))
n2 = int(input('Enter Second Number: '))

if n1 > n2:
    print(f'{n1} is greater than {n2}')
else:
    print(f'{n1} is smaller than {n2}')

545 is greater than 54

# 2. Iterative Statements :-

# for loop
# while loop

# 1. for loop :-

    # for every element present in the given sequence, if we want to perform certain activity then we should go for for loop.

# for x in sequence:
    # body

l = [10,20,30,40,50,60]
s = {10,20,30,40,50,60}

for x in l:
    print(x)

10
20
30
40
50
60

x = 'durga'

for ch in x:
    print('The Current Character is:',ch)

The Current Character is: d
The Current Character is: u
The Current Character is: r
The Current Character is: g
The Current Character is: a

s = input('Enter Any String:')
i = 0

for ch in s:
    print('The Character Present at', i, 'index:', ch)
    i += 1

The Character Present at 0 index: 3
The Character Present at 1 index: 4
The Character Present at 2 index: k
The Character Present at 3 index: j
The Character Present at 4 index: b
The Character Present at 5 index: g

for x in range(10):
    print('Hello')

Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello

for x in range(10):
    print(x)

0
1
2
3
4
5
6
7
8
9

for x in range(1, 21):
    if x%2 == 0:
        print(x)

2
4
6
8
10
12
14
16
18
20

for x in range(10, 0, -1):
    print(x)

10
9
8
7
6
5
4
3
2
1

# To print the sum of numbers present in the given list?

l = eval(input('Enter List:'))
print(l)
sum = 0
for x in l:
    sum += x
print('Sum is:', sum)

(10, 10, 20, 30, 40, 50)
Sum is: 160

# while loop :-

    # We don't know the number of iteration in advance, as long as some condition is True, execute body 

# while condition:
    # True

# To print numbers from 1 to 10 by using while loop?

x = 1
while x <= 10:
    print(x)
    x += 1

1
2
3
4
5
6
7
8
9
10

# # Note :-
    # for loop is sequence based

    # while loop is condition based

# To display the sum of first n natural numbers?

n = int(input('Enter n values:'))
sum = 0
i = 1
while i <= n:
    sum += i
    i += 1
print('The sum of First {} Numbers: {}'.format(n, sum))

The sum of First 9 numbers: 45

name = ''
i = 1
while name != 'sunny' and i<=10:
    name = input('Enter Name:')
    print('Enter Name:', name)
    i += 1

Enter Name: 454
Enter Name: SADA
Enter Name: ASDSLAMF
Enter Name: DSFKLER
Enter Name: KVNFA
Enter Name: KNAFSKASF
Enter Name: FAKSNFK
Enter Name: MLSNFL
Enter Name: MCKEANF
Enter Name: sunny

name = ''
i = 1
while name != 'sunny' and i<=10:
    name = input('Enter Name:')
    print('Enter Name:', name)
    i += 1
    if i == 10:
        print('You entered more than 10 times. Exiting...')
        break

print('Thanks for Confirmation')

Enter Name: sfew
Enter Name: wgrw
Enter Name: eg
Enter Name: erwg
Enter Name: wrgrw
Enter Name: g
Enter Name: gtrt
Enter Name: wgw
Enter Name: rg
You entered more than 10 times. Exiting...
Thanks for Confirmation

# name != 'sunny' and i<=10     ===> Returns False then only it will be stopped

# name != 'sunny'   ===> If you enter name as sunny the the result is False
# i<=10     ===> If i value > 10 then it results False

# Infinite Loop :-
# Nested Loop :-
    # Loop inside another loop

for i in range(4):
    for j in range(4):
        print(i, j)

0 0
0 1
0 2
0 3
1 0
1 1
1 2
1 3
2 0
2 1
2 2
2 3
3 0
3 1
3 2
3 3

# read data from the end user as long as he poviding valing input

# while data is invalid:
    # read data from the user

# while True:
    # read data from the user
    # if data is valid:
        # break

while True:
    username = input('Enter User Name:')
    pwd = input('Enter Password:')
    if username == 'durga' and pwd == 'sunny':
        print('Login Successful')
        break
    else:
        print('Invalid Credentials. Please try again.')

Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Login Successful

n = int(input('Enter any Number:'))

for i in range(n):
    print('*', end=' ')

* * * * * 

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(n):
        print('*', end=' ')
    print()

* * * 
* * * 
* * * 

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(n):
        print(n, end=' ')
    print()

3 3 3 
3 3 3 
3 3 3 

n = int(input('Enter any Number:'))

for i in range(n):
    print('A '*n)

A A A A A A 
A A A A A A 
A A A A A A 
A A A A A A 
A A A A A A 
A A A A A A 

n = int(input('Enter any Number:'))

for i in range(n):
    print((str(i+1) + ' ')* n)

1 1 
2 2 

n = int(input('Enter any Number:'))

for i in range(n): # for every row
    for j in range(n): # for every column in that row
        print(i+1, end=' ')
    print()

1 1 1 1 1 
2 2 2 2 2 
3 3 3 3 3 
4 4 4 4 4 
5 5 5 5 5 

n = int(input('Enter any Number:'))

for i in range(n): # for every row
    for j in range(n): # for every column in that row
        print(i, end=' ')
    print()

0 0 0 0 0 
1 1 1 1 1 
2 2 2 2 2 
3 3 3 3 3 
4 4 4 4 4 

n = int(input('Enter any Number:'))

for i in range(n): # for every row
    for j in range(n): # for every column in that row
        print(chr(65+i), end=' ')
    print()

A A A A A A A A A 
B B B B B B B B B 
C C C C C C C C C 
D D D D D D D D D 
E E E E E E E E E 
F F F F F F F F F 
G G G G G G G G G 
H H H H H H H H H 
I I I I I I I I I 

n = int(input('Enter any Number:'))

for i in range(n): # for every row i = 1,2,3,4,....,n
    for j in range(n):  # j = 1,2,3,4,..,n
        print(j+1, end=' ')
    print()

1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 

n = int(input('Enter any Number:'))

for i in range(1, n+1): # for every row i = 1,2,3,4,....,n
    for j in range(1, n+1):  # j = 1,2,3,4,..,n
        print(j+1, end=' ')
    print()

2 3 4 5 6 
2 3 4 5 6 
2 3 4 5 6 
2 3 4 5 6 
2 3 4 5 6 

n = int(input('Enter any Number:'))

for i in range(1, n+1): # for every row i = 1,2,3,4,....,n
    for j in range(1, n+1):  # j = 1,2,3,4,..,n
        print(j, end=' ')
    print()

1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 

n = int(input('Enter any Number:'))

for i in range(n): # for every row i = 1,2,3,4,....,n
    for j in range(n):  # j = 1,2,3,4,..,n
        print(n-j, end=' ')
    print()

5 4 3 2 1 
5 4 3 2 1 
5 4 3 2 1 
5 4 3 2 1 
5 4 3 2 1 

for i in range(10, 1, -1):
    print(i)

10
9
8
7
6
5
4
3
2

n = int(input('Enter any Number:'))

for i in range(n):
    print('*' * (i+1))

*
**
***

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(i+1):
        print('*', end=' ')
    print()

* 
* * 
* * * 

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(i+1):
        print(n-j, end=' ')
    print()

5 
5 4 
5 4 3 
5 4 3 2 
5 4 3 2 1 

n = int(input('Enter any Number:'))

for i in range(n):
    print(' '*(n-i-1), end='')
    print('* '*(i+1))

    * 
   * * 
  * * * 
 * * * * 
* * * * * 

# Transfer Statements :-

# 1. break
# 2. continue

# pass and del

# 1. break statement :-

# break loop execution based on some condition

for i in range(10):
    print(i)

0
1
2
3
4
5
6
7
8
9

for i in range(10):
    print(i)
    if i == 5:
        print('Loop Execution enough... plz break!!')
        break;

0
1
2
3
4
5
Loop Execution enough... plz break!!

cart = [10,20,30,40,600,50,60]

for items in cart:
    if items > 500:
        print('To place this order, insurance must be required')
        break
    print(items)

10
20
30
40
To place this order, insurance must be required

# 2. continue statement :-

# we can use continue statement to skip current iteration and continue for the next iteration.

for i in range(10):
    if i == 5:
        continue
    print(i)

0
1
2
3
4
6
7
8
9

for i in range(10):
    if i%2 == 0:
        continue
    print(i)

1
3
5
7
9

for i in range(10):
    if i%2 != 0:
        continue
    print(i)

0
2
4
6
8

cart = [10,20,30,40,600,500,60]

for item in cart:
    if item >= 500:
        print('We cannot process this item beacuse of insurance issue:', item)
        continue
    print('Processing item:', item)

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
We cannot process this item beacuse of insurance issue: 600
We cannot process this item beacuse of insurance issue: 500
Processing item: 60

numbers = [10,20,0,5,0,30]

for n in numbers:
    if n == 0:
        print('We cannot divide with 0')
        continue
    print('100/{} = {}'.format(n, 100/n))

100/10 = 10.0
100/20 = 5.0
We cannot divide with 0
100/5 = 20.0
We cannot divide with 0
100/30 = 3.3333333333333335

numbers = [10,20,0,5,0,30]

for n in numbers:
    if n == 0:
        print('We cannot divide with 0')
        continue
    print('100/{a} = {b}'.format(a=n, b=100/n))

100/10 = 10.0
100/20 = 5.0
We cannot divide with 0
100/5 = 20.0
We cannot divide with 0
100/30 = 3.3333333333333335

# if-else
# for-else
# while-else
# try-else-except-finally

# else block :-

# loops with else block :-

    # 1. some times loop will be executed with out break
    # 2. some times loop will be terminated because of break

# inside loop execution if break statement not executed, then only else part will be executed
# else means loop without break

# else is always associated with break
# without break we can use else but not that much meaningful.

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
Processing item: 50

cart = [10,20,30,40,500]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
we cannot place this order

cart = [10,20,30,40,500]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
we cannot place this order

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
Processing item: 50
Congrats!

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        continue
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
Processing item: 50
Congrats!

cart = [10,20,30,40,500]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        continue
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
we cannot place this order
Congrats!

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)
    for i in range(2):
        if i == 1:
            break
        print(i)
else:
    print('Congrats!')

Processing item: 10
0
Processing item: 20
0
Processing item: 30
0
Processing item: 40
0
Processing item: 50
0
Congrats!

# 1. Selection Statements/Conditional Statements :-
    # if
    # if-else
    # if-elif
    # if-elif-else

# 2. Iteration Statements (Loops) :-
    # for
    # while
    # for-else
    # while-else
    # else will be executed if there is no break statement

# 3. Transfer Statements :-
    # break
    # continue

# # pass and del :-

# pass :-

# it is a keyword in python

# it is empty statement
# it is null statement
# it won't do anything

if 10>20:
    print('Hello')
else:

  Cell In[10], line 3
    else:
         ^
SyntaxError: incomplete input

if 10>20:
    print('Hello')
else:
    pass

class Loan:
    pass

class GoldLoan(Loan):
    pass

class HomeLoan(Loan):
    pass

class CarLoan(Loan):
    pass

class Loan:
    def getInterestRate(self):
        pass

class GoldLoan(Loan):
    def getInterestRate(self):
        return 10

class HomeLoan(Loan):
    def getInterestRate(self):
        return 7

class CarLoan(Loan):
    def getInterestRate(self):
        return 13

# del :-

s1 = 'durga'
print(s1)

durga

s1 = 'durga'
del s1
print(s1)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[12], line 3
      1 s1 = 'durga'
      2 del s1
----> 3 print(s1)

NameError: name 's1' is not defined

s1 = 'durga'
s1 = None
print(s1)

None

s1 = 'durga'
print(s1)

print(s1[0])

durga
d

del s1[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[18], line 1
----> 1 del s1[0]

TypeError: 'str' object doesn't support item deletion

# pass ===> empty statement
# del ===> to delete variable which are no longer required in our progream automatically the corresponding objects for gc.
        # if useless objects deleted, free memory will be improved our program won't face memory issues.

del 'durga'

  Cell In[21], line 1
    del 'durga'
        ^
SyntaxError: cannot delete literal

s = 'durga'
del s

# # String Data Types :-

s = 'durga'
s = 'ravi'

# either single quotes or double quotes

ch = 'a'

s = '''durga
software
solutions'''
print(s)

durga
software
solutions

# 1. To define multiline string literals.
# 2. To use single o rdouble quotes as symbol only.
# 3. Doc string.

s = '''The classes of 'Python' by "Durga Sir" are good'''
print(s)

The classes of 'Python' by "Durga Sir" are good

s = 'The classes of \'Python\' by \"Durga Sir\" are good'
print(s)

The classes of 'Python' by "Durga Sir" are good

# How to access character of the string :-
    # 1. By using index
    # 2. By using Slice Operator

# 1. By using index :-

# Python supports both +ve and -ve indices :-

# +ve index is always from left to right starts from 0.
# -ve index is always from right to left starts from -1.

s = 'durga'
print(s)
print(s[0])
print(s[1])
print(s[2])
print(s[3])
print(s[4])

durga
d
u
r
g
a

print(s[5])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[20], line 1
----> 1 print(s[5])

IndexError: string index out of range

s = 'durga'
print(s)
print(s[-1])
print(s[-2])
print(s[-3])
print(s[-4])
print(s[-5])

durga
a
g
r
u
d

print(s[-6])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[22], line 1
----> 1 print(s[-6])

IndexError: string index out of range

# Question :-
    # Write a program to read string from the keyboard and display its characters by index wise(both positive index and negative index)?

s = input('Enter String:')
i = 0

for x in s:
    print('The Character Present at', i, 'index:', x)
    i += 1


# Not correct
j = -len(s)
print(j)
for x in s[::-1]:
    print('The Character Present at', j, 'index:', x)
    j += 1

The Character Present at 0 index: a
The Character Present at 1 index: s
The Character Present at 2 index: d
-3
The Character Present at -3 index: d
The Character Present at -2 index: s
The Character Present at -1 index: a

s = input('Enter any String:')
i = 0
for x in s:
    print('The Character Present at Positive Index {} and at Negative Index {} is : {}'. format(i, i-len(s), x))
    i += 1

The Character Present at Positive Index 0 and at Negative Index -3 is : a
The Character Present at Positive Index 1 and at Negative Index -2 is : s
The Character Present at Positive Index 2 and at Negative Index -1 is : d

# 2. By using Slice Operator :-

# s[begin_index:end_index:step]
# s[begin:end:step]

# s[begin_index:end_index]
# from begin_index to end_index

# begin is optional

s = 'Learning Python is very Easy'

s[:]

'Learning Python is very Easy'

s[:7]

'Learnin'

s[1:7]

'earnin'

s[1:7:1]

'earnin'

s[1:7:2]

'eri'

s = 'abcdefghijklmnopqrstuvwxyz'

s[1:15:1]

'bcdefghijklmno'

s[1:15:3]

'behkn'

# for begin and end we can take either positive index or negative index

s[1:10000:1]

'bcdefghijklmnopqrstuvwxyz'

# Slice Operator won't raise index error

s[11100:1000:1]

''

s[-5:-9:-1]

'vuts'

# steps value can be either positive or negative.
# The default step value is: +1.

# +ve step value means forward direction(left to right)
    # from begin to end-1 index

# -ve step value means backward direction(right to left)
    # from end to begin-1 index

s[::1]

'abcdefghijklmnopqrstuvwxyz'

s[::-1]

'zyxwvutsrqponmlkjihgfedcba'

# In Forward Direction:
    # default begin value: 0
    # default end value: len(s)
    # default step value: +1

# In Backward Direction:
    # default begin value: -1
    # default end value: -len(s)+1
    # default step value: -1

s

'abcdefghijklmnopqrstuvwxyz'

s[::-1]

'zyxwvutsrqponmlkjihgfedcba'

len(s)

26

s[-1:-27:-1]

'zyxwvutsrqponmlkjihgfedcba'

# In Forward direction if end value is 0 then result is always empty.

# In Backward direction if end value is -1 then result is always empty.

# s[begin:end:step]
# all attributes are optional
# all values can be either positive or negative

# if step is +ve then forward direction from begin to end-1
# if step is -ve then backward direction from begin to end+1

s = 'abcdefghij'

s[1:6:2]

'bdf'

s[3:7:-1]

''

s[7:4:-1]

'hgf'

s[0:10000:1]

'abcdefghij'

s[1:10000:-1]

''

s[-4:1:-1]

'gfedc'

s[-4:1:-2]

'gec'

s[5:0:1]

''

s[9:0:0]

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[11], line 1
----> 1 s[9:0:0]

ValueError: slice step cannot be zero

s[0:-10:-1]

''

s[-1:-1:-1]

''

s[0:-2:1]

'abcdefgh'

s[1:7:3]

'be'

s[7:1:-3]

'he'

s = input('Enter any string')
print('In Forward direction')
i= 0
while i< len(s):
    print(s[i])
    i+=1

print('In Backward direction')
i = -1
while i > -len(s)-1:
    print(s[i])
    i -= 1

In Forward direction
4
5
6
In Backward direction
6
5
4

# Membership Operator :-

# in
# not in

s = 'durga'

'a' in s

True

'b' in s

False

'b' not in s

True

# Number to Word Conversion :-

s = int(input('Enter the number:'))
s = s%26
num = 65 + s
word = chr(num)
print(word)

M

# Comparison of Strings :-

# >, >=, <=, <, ==

s1 = input('Enter First String:')
s2 = input('Enter Second String:')

if s1 == s2:
    print('Both Strings are equal.')
elif s1 > s2:
    print('First String is greater than Second String.')
else:
    print('First String is smaller than Second String.')

Both Strings are equal.

city = input('Enter City:')

if city == 'Hyderabad':
    print('Hello Hyderabadi...Aadaab')
elif city == 'Chennai':
    print('Hello Madrasi...Vanakkam')
elif city == 'Bangalore':
    print('Hello Kannadiga...Namaskaran')
else:
    print('I am not familiar with', city)

I am not familiar with 456

# Remove Spaces From the Strings :-

# # Remove Spaces From the Strings :-

# rstrip ---> To remove spaces at right hand side(end of the string)
# lstrip ---> To remove spaces from left hand side(beginning of the string)
# strip ---> To remove both sides

# but it will not work on spaces b/w the words
    # ex. it will not work on 'Hydera    bad'

city = input('Enter City:').strip()

if city == 'Hyderabad':
    print('Hello Hyderabadi...Aadaab')
elif city == 'Chennai':
    print('Hello Madrasi...Vanakkam')
elif city == 'Bangalore':
    print('Hello Kannadiga...Namaskaran')
else:
    print('I am not familiar with', city)

Hello Hyderabadi...Aadaab

city = input('Enter City:').strip().lower()

if city == 'hyderabad':
    print('Hello Hyderabadi...Aadaab')
elif city == 'chennai':
    print('Hello Madrasi...Vanakkam')
elif city == 'bangalore':
    print('Hello Kannadiga...Namaskaran')
else:
    print('I am not familiar with', city)

I am not familiar with ghdshas

# Finding Substrings :-

# # Finding Substrings :-

    # find()
    # index()

    # rfind()
    # rindex()

# string.find(substring)
    # Returns index of first occurrence of the given substring
    # Returns -1 if it is not available

# find() will search complete string until finding the first occurrence in forward direction

s = 'Learning Python is very Python easy study Python'
s.find('Python')

9

s.find('Java')

-1

# Membership Operator :- (in and not in)
    # provide True and False
# in ===> True

s.find('r')

3

s.rfind('Python')

42

# find(substring)

# find(substring, begin, end)
    # from begin to end-1

s.find('Python', 1, 6)

-1

s.find('Python', 1, 26)

9

s = 'Learning python is very easy'

s.find('p')

9

len(s)

28

s = 'abc'
len(s)

3

s = 'Learning python is very easy'
s.rfind('y')

27

# index() :-

    # index() method is exactly same as find() method except that if the specified substring is not available then we will get ValueError.

s.find('p')

9

s.index('p')

9

s.find('pt')

-1

s.index('pt')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[14], line 1
----> 1 s.index('pt')

ValueError: substring not found

# Program to display all positions of the substring in the given main string?

s = input('Enter the String:')
subs = input('Character to Find in String:')
print('String:', s)
print('Character:', subs)

count = 0
for i in s:
    if i == subs:
        count += 1

print(count)

String asafasdf
Character a
3

s = input('Enter Main String:')
subs = input('Enter Sub String:')

print('Main String:', s)
print('Sub String:', subs)

n = len(s)
pos = 0
count = 0

while True:
    i = s.find(subs, pos, n)
    if i == -1:
        print('The Total Number of Times Sub String Found:', count)
        break
    else:
        print('Found at index:', i)
        count += 1
        pos = i + len(subs)
        i = s.find(subs, pos, n)

Main String: asdfghjkasdfasdfgasasas
Sub String: a
Found at index: 0
Found at index: 8
Found at index: 12
Found at index: 17
Found at index: 19
Found at index: 21
The Total Number of Times Sub String Found: 6

# Counting Sub-String in the Given String :-

# count() method

# s.count(substring)
# s.count(substring, begin, end)

s = input('Enter Main String:')
subs = input('Enter Sub String:')
print('The Total Number of Times Sub String Found:', s.count(subs))
print('The Total Number of Times Sub String Found:', s.count(subs, 4, 10))

The Total Number of Times Sub String Found: 5
The Total Number of Times Sub String Found: 0

# Replacing a String with Another String :-

# ab ---> xy

# s.replace('ab', 'xy')

s = 'Learning Python is very difficult'

s1 = s.replace('difficult', 'easy')
s1

'Learning Python is very easy'

# Write a script to remove spaces in the given string?
# strip() ---> begining and end of the string but not middle blank spaces

s = 'ab a b aba b a bab'
s1 = s.replace(' ', '')
s1

'abababababab'

s = 'ab a b aba b a bab'
s1 = s.replace(' ', '')

print(len(s)-len(s1))

6

s = 'ab a b aba b a bab'
s

'ab a b aba b a bab'

s1 = s.replace(' ', '')
s1

'abababababab'

s

'ab a b aba b a bab'

# Splitting of Strings :-

# s.split(separator)

s = 'durga software solutions'
s

'durga software solutions'

l = s.split(' ')
l

['durga', 'software', 'solutions']

for x in l:
    print(x)

durga
software
solutions

s = '01-08-2020'
s

'01-08-2020'

l = s.split('-')
l

['01', '08', '2020']

type(l)

list

for x in l:
    print(x)

01
08
2020

s

'01-08-2020'

s = 'hello'
s

'hello'

s[0] = 'p'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[64], line 1
----> 1 s[0] = 'p'

TypeError: 'str' object does not support item assignment

# Joining of Strings :-

# a group of strings(list or tuple) can be joined by using the the given delimiter.

# l = s.split(separator)

# s = separator.join(group of strings)

l = ['sunny', 'bunny', 'hunny']
l

['sunny', 'bunny', 'hunny']

s = '-'.join(l)
s

'sunny-bunny-hunny'

l

['sunny', 'bunny', 'hunny']

t = ('10','20','30')
t

('10', '20', '30')

s = '-'.join(t)
s

'10-20-30'

s = ''.join(t)
s

'102030'

s = ','.join(t)
s

'10,20,30'

# split() ===> str to list
# join() ===> list/tuple to str

# Changing Case of a String :-

# 1. upper() ---> Every lower case character will be converted into upper case

# 2. lower() ---> Every upper case character will be converted into lower case

# 3. swapcase() ---> lower-->upper and upper-->lower

# 4. title() ---> First character of every word in upper case

# 5. capitalize ---> First word of it in uppercase remaing in lower

s = 'learning PYTHON is very easy'
s

'learning PYTHON is very easy'

s.upper()

'LEARNING PYTHON IS VERY EASY'

s.lower()

'learning python is very easy'

s.swapcase()

'LEARNING python IS VERY EASY'

s.title()

'Learning Python Is Very Easy'

s.capitalize()

'Learning python is very easy'

# To check Type of Characters Present in the Given String :-

# 1. isalnum() ---> a to z, A to Z, 0 to 9

# 2. isalpha() ---> a to z, A to Z

# 3. isdigit() ---> 0 to 9

# 4. islower() ---> If every alphabet is in lower case

# 5. isupper() ---> If every alphabet is in upper case

# 6. istitle() ---> If the string is in title case

# 7. isspace() ---> If the string contains only spaces

'Durga786'.isalnum()

True

'durga786'.isalpha()

False

'DurgA'.isalpha()

True

'123456'.isdigit()

True

'durga'.islower()

True

'DURga'.islower()

False

'durga1234'.islower()

True

'ABC123'.isupper()

True

'ABCd'.isupper()

False

'Learning Python is very easy'.istitle()

False

'Learning Python Is Very Easy'.istitle()

True

'       '.isspace()

True

'a   '.isspace()

False

'        a'.isspace()

False

'Durga 123'.isalnum()

False

'Dur  ga'.isalpha()

False

s = input('Enter ANY Character:')
print(s)
if s.isalnum():
    print('The Character is Alphanumeric.')
    if s.isalpha():
        print('The Character is Alphabet.')
        if s.islower():
            print('The Character is Lowercase.')
        else:
            print('The Character is Uppercase.')
    elif s.isdigit():
        print('It is a digit.')
    else:
        print('It is a Mixed String.')
elif s.isspace():
    print('It is Space Character.')
else:
    print('Non Space Special Character.')

23125safsda
The Character is Alphanumeric.
It is a Mixed String.

# Checking Starting and Ending Part of the String :-

# s.startswith(substring)

# s.endswith(substring)

s = 'learning python is very easy'
s

'learning python is very easy'

s.startswith('l')

True

s.startswith('learning python')

True

s.endswith('learning python')

False

s.endswith('sy')

True

s.endswith('very easy')

True

# # Important programs regarding string concept?

# Q1: Write a program to reverse the given string?

str = input('Enter any String:')
print('String:', str)
reverse_str = ''

for i in str[::-1]:
    reverse_str = reverse_str + i

print('Reversed String:', reverse_str)

String: asd
Reversed String: dsa

str = input('Enter any String:')
print('String:', str)

r = reversed(str)
print(type(r))
print(r)

output = ''.join(r)
print('Reversed String:', output)

String: asdg
<class 'reversed'>
<reversed object at 0x00000106A384AA10>
Reversed String: gdsa

str = input('Enter any String:')
print('String:', str)

i = len(str) - 1
target = ''

while i >= 0:
    target += str[i]
    i -= 1
print('Reversed String:', target)

String: asd
Reversed String: dsa

# Q2: Program to reverse order of words?

str = input('Enter any String:')
print('String:', str)

l = str.split()
print(l)
l1 = []
i = len(l)-1

while i >= 0:
    print(l[i])
    l1.append(l[i])
    i -= 1

print('Reversed List:', l1)
print('Reversed Order of Words:', ' '.join(l1))

String: asad cdv vdfb
['asad', 'cdv', 'vdfb']
vdfb
cdv
asad
Reversed String: ['vdfb', 'cdv', 'asad']
Reversed Order of Words: vdfb cdv asad

str = input('Enter any String:')
print('String:', str)

l = str.split()
print(l)

for i in range(len(l)):
    print(l[i])

String: as cd vf
['as', 'cd', 'vf']
as
cd
vf

str = input('Enter any String:')
print('String:', str)

l = str.split()
print(l)
l1 = []
i = len(l)-1

while i >= 0:
    print(l[i])
    l1.append(l[i])
    i -= 1

print('Reversed List:', l1)
print('Reversed Order of Words:', '-'.join(l1))

String: as df gh
['as', 'df', 'gh']
gh
df
as
Reversed List: ['gh', 'df', 'as']
Reversed Order of Words: gh-df-as

# Q3: Program to reverse internal content of each word?

    # input: one two three
    # output: eno owt eerht

s = 'one two three'
print(s)

l = s.split()
print(l)

l1 = []

for x in l:
    l1.append(x[::-1])

print(l1)
output = ' '.join(l1)
print(output)

one two three
['one', 'two', 'three']
['eno', 'owt', 'eerht']
eno owt eerht

# Q4: Program to print cahracters at odd position and even position for the given string?

s = 'abcdefgh'

even = ''
odd = ''

for i in range(len(s)):
    if i % 2 == 0:
        even += s[i]
    else:
        odd += s[i]

print('Even Position Characters:', even)
print('Odd Position Characters:', odd)

Even Position Characters: aceg
Odd Position Characters: bdfh

s = 'abcdefgh'

print('Character at even position:', s[::2])
print('Character at odd position:', s[1::2])

Character at even position: aceg
Character at odd position: bdfh

s = 'abcdefgh'

print('Character at even Position')
i = 0
while i < len(s):
    print(s[i], end=',')
    i += 2

print('\nCharacter at odd Position')
i = 1
while i < len(s):
    print(s[i], end=',')
    i += 2

Character at even position
a,c,e,g,
Character at odd Position
b,d,f,h,

s = 'abcdefgh'

even = []
odd = []

for i in range(len(s)):
    if i % 2 == 0:
        even.append(s[i])
    else:
        odd.append(s[i])

print('Even Position Characters:', even)
print('Odd Position Characters:', odd)

Even Position Characters: ['a', 'c', 'e', 'g']
Odd Position Characters: ['b', 'd', 'f', 'h']

# Q5: Program to merge characters of 2 strings into a single string by taking characters alternatively?

s1 = 'ravi'
s2 = 'teja'

output = ''
i,j = 0, 0

while i < len(s1) or j < len(s2):
    output = output + s1[i] + s2[j]
    i += 1
    j += 1

print(output)

rtaevjia

s1 = 'ravikarn'
s2 = 'teja'

output = ''
i,j = 0, 0

while i < len(s1) or j < len(s2):
    output = output + s1[i] + s2[j]
    i += 1
    j += 1

print(output)

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[51], line 8
      5 i,j = 0, 0
      7 while i < len(s1) or j < len(s2):
----> 8     output = output + s1[i] + s2[j]
      9     i += 1
     10     j += 1

IndexError: string index out of range

s1 = 'ravikarn'
s2 = 'teja'

output = ''
i,j = 0, 0

while i < len(s1) or j < len(s2):
    if i < len(s1):
        output = output + s1[i]
        i += 1
    if j < len(s2):
        output = output + s2[j]
        j += 1

print(output)

rtaevjiakarn

# Q6: Program to sort characters present in the given string. First alphabet symbols and then numeric values?

    # input: B4A1D3
    # output: ABD134

s = 'B4A1D3'

s1 = s2 = ''

for x in s:
    if x.isalpha():
        s1 = s1 +x
    else:
        s2 = s2 + x

print(s1)
print(s2)

print(sorted(s1))
print(sorted(s2))

output = ''
for x in sorted(s1):
    output = output + x
for x in sorted(s2):
    output = output + x

print(output)

BAD
413
['A', 'B', 'D']
['1', '3', '4']
ABD134

s = 'B4A1D3'

s1 = s2 = ''

for x in s:
    if x.isalpha():
        s1 = s1 +x
    else:
        s2 = s2 + x

print(s1)
print(s2)

print(sorted(s1))
print(sorted(s2))

output = ''.join(sorted(s1) + sorted(s2))

print(output)

BAD
413
['A', 'B', 'D']
['1', '3', '4']
ABD134

# input: a4b3c2
# output: aaaabbbcc

s = 'a4b3c2'
output = ''

for x in s:
    if x.isalpha():
        ch = x
    else:
        output = output + ch*int(x)

print(output)

aaaabbbcc

s = 'ab2cd2e2'
output = ''
ch = ''

for x in s:
    if x.isalpha():
        ch = ch + x
    else:
        output = output + ch*int(x)
        ch = ''

print(output)

ababcdcdee

s = 'ab2cd2e2'
output = ''
num = ''
i = 0

while i < len(s):
    if s[i].isalpha():
        ch = s[i]
    else:
        num = num + s[i]
        if i == len(s)-1:
            output = output + ch*int(num)

        if i+1 < len(s) and s[i+1].isalpha():
            output = output + ch*int(num)
            num = ''
    i = i+1
print(output)

bbddee

s = 'ab10cd2e2'
output = ''
num = ''
str = ''
i = 0

while i < len(s):
    if s[i].isalpha() and s[i+1].isalpha():
        output = output + s[i]
    elif s[i].isalpha():
        ch = s[i]
    else:
        num = num + s[i]
        if i == len(s)-1:
            output = output + ch*int(num)

        if i+1 < len(s) and s[i+1].isalpha():
            output = output + ch*int(num)
            num = ''
    i = i+1
print(output)

abbbbbbbbbbcddee

# input: a4k3b2
# output: aeknbd

ord('a')

97

chr(96)

'`'

s = 'ab24k10ba27'
output = ''
num = ''

for i in range(len(s)):
    if s[i].isalpha():
        ch = s[i]
        output = output + ch

    else:
        num = num + s[i]
        if i == len(s) - 1:
            neword = ord(ch) + int(num)
            if neword >= 123:
                neword = (neword % 123) + 97
            newch = chr(neword)
            output = output + newch

        if i+1< len(s) and s[i+1].isalpha():
            neword = ord(ch) + int(num)
            if neword >= 123:
                neword = (neword % 123) + 97
            newch = chr(neword)
            output = output + newch
            num = ''

print(output)

122
117
124
abzkubab

# Q: Program to remove duplicate characters present in the given string?

s = 'aaaabbbcccddd'
l = []

for i in s:
    if i not in l:
        l.append(i)

print(l)
''.join(l)

['a', 'b', 'c', 'd']

'abcd'

s = input('Enter any String:')
l = []

for i in s:
    if i not in l:
        l.append(i)

print(l)
output = sorted(l)
output = ''.join(output)
output = output.replace(' ', '')
print(output)

['a', 's', 'd', ' ', 'm', 'e', 'j', 'v', 'f', 'n']
adefjmnsv

# Q: Program to find the number of occurrences of each character present in the given string?

d = {}
d ['a'] = 1
d['a'] = d['a']+1
print(d)

{'a': 2}

s = 'abcabcabbcde'
d = {}

for x in s:
    if x not in d:
        d[x] = 1
    else:
        d[x] = d[x] + 1

print(d)

for k,v in d.items():
    print('{} occurs {} times'.format(k, v))

{'a': 3, 'b': 4, 'c': 3, 'd': 1, 'e': 1}
a occurs 3 times
b occurs 4 times
c occurs 3 times
d occurs 1 times
e occurs 1 times

# # Collection Related DataType :-

# List
# Tuple
# Set
# Dictionary

# # List :-

# If we want to present a group of individual objects as a single entity wher insertion order preserved and duplicate objects are allowed, then we should go for list.

# 1. insertion order preserved
# 2. duplicate are allowed
# 3. Heterogeneous objects
# 4. It is dynamic ---> increase/decrease
# 5. mutable
# 6. indexing and slicing concepts are applicable
# 7. []
# 8. +ve and -ve index

# Creation of List Objects :-

# 1. empty list :-

l = []
l

[]

# 2. if we know elements already :-

l = [10,20,30]
l

[10, 20, 30]

# 3. with dynamic input :-

l = eval(input('enter list:'))
print(l)
print(type(l))

[10, 20, 30, 40]
<class 'list'>

l = list(range(1,11,2))
print(l)
print(type(l))

[1, 3, 5, 7, 9]
<class 'list'>

l = list(input('Enter String:'))
print(type(l))
print(l)

<class 'list'>
['a', 'd', 's', 's', 'a', 'f', 'd', 's']

# 4. list() function :-

    # l = list(any other sequence)
    # l = list(range(10))

l = list(range(1,11,3))
print(type(l))
print(l)

<class 'list'>
[1, 4, 7, 10]

l = []
print(type(l))
print(l)

<class 'list'>
[]

l = list([10,20,30,40])
print(type(l))
print(l)

<class 'list'>
[10, 20, 30, 40]

l = list({10,20,30,40})
print(type(l))
print(l)

<class 'list'>
[40, 10, 20, 30]

# 5. string class split() method :-

s = 'Learning Python is very easy'
s

'Learning Python is very easy'

l = s.split()
l

['Learning', 'Python', 'is', 'very', 'easy']

# Accessing Elements of List :-

# by using index
# by using slice operator

# # by using index :-

l = [10,20,30,40]
l

[10, 20, 30, 40]

l[0]

10

l[-1]

40

l[3]

40

l[100]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[39], line 1
----> 1 l[100]

IndexError: list index out of range

# # by using slice operator :-

# l[begin:end:step]

# In Forward direction:
    # beging to end-1

# In Backward direction:
    # begin to end+1

l = [10,20,30,40]
l

[10, 20, 30, 40]

l = list('abcdefghijk')
l

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

#  -11  -10  -9   -8   -7   -6   -5   -4   -3   -2   -1

# ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

#   0    1    2    3    4    5    6    7    8    9    10

l[2:7:2]

['c', 'e', 'g']

l[4::2] # from 4 to end-1 (i.e 10)

['e', 'g', 'i', 'k']

l[8:2:-2] # from 8 to 3

['i', 'g', 'e']

l[4:24642:2]

['e', 'g', 'i', 'k']

# list, tuple, string ---> indexing/slicing possible
# set, dictionary ---> indexing/slicing not possible

# beacuse order is not fixed

# # List vs Mutability :-

l = [10,20,30,40]
l

[10, 20, 30, 40]

id(l)

2831139062592

l[0] = 777
l

[777, 20, 30, 40]

id(l)

2831139062592

# Traversing the Elements of List :-

# # Display all elements of list by using while loop :-

l = [10,20,30,40,50]
i = 0
while i < len(l):
    print(l[i])
    i += 1

10
20
30
40
50

l = [10,20,30,40,50]
for x in l:
    print(x)

10
20
30
40
50

# Display only even numbers :-

l = [0,1,2,3,4,5,6,7,8,9,10]
for x in l:
    if x % 2 == 0:
        print(x)

0
2
4
6
8
10

# To access element on base of index use where loop
# for element base use for loop

l = [10,20,30,40]
i = 0
while i<len(l):
    print('The element present at positive index: {} and negative index: {} is: {}'.format(i, i-len(l), l[i]))
    i += 1

The element present at positive index: 0 and negative index: -4 is: 10
The element present at positive index: 1 and negative index: -3 is: 20
The element present at positive index: 2 and negative index: -2 is: 30
The element present at positive index: 3 and negative index: -1 is: 40

# # # List Data Structure :-

# Important Functions and Methods of List :-

# functions ---> POP Concept(Procedural Oriented Programming)
# methods ---> OOP Concept(Object Oriented Programming)

def f1():
    print('f1 function')

class Test:
    def m1(self):
        print('m1 method')

f1()

f1 function

test = Test()
test.m1()

m1 method

s = 'durga'
print(len(s))
print(s.upper())

5
DURGA

# 1. To get information of List :-

# 1. len() :-
    # to retrun the number of elements present in the list

l = [10,20,30,40]
len(l)

4

# 2. count() :-
    # it returns the number of occurrences of specified element

l = [10,20,30,40,10,30,40,10]
l.count(10)

3

l.count(40)

2

l.count(50)

0

# 3. index() :-
    # it returns the index of the first occurrence of specified element

    # ValueError if the element is not present in the list

    # membership operator: in

l = [10,20,30,40,10,30,40,10]
l.index(10)

0

l.index(40)

3

l.index(50)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[25], line 1
----> 1 l.index(50)

ValueError: 50 is not in list

l = [1,2,3,1,1,1,4]

x = int(input('Enter any Element to Find Index:'))

i = l.index(x)

print('{} element first occurrence index is: {}'.format(x,i))

4 element first occurrence index is: 6

l = [1,2,3,1,1,1,4]

x = int(input('Enter any Element to Find Index:'))

if x in l:
    i = l.index(x)
    print('{} element first occurrence index is: {}'.format(x,i))

else:
    print('{} element is not present in the list'.format(x))

8 element is not present in the list

# 2. Manipulating Elements of List :-

# 1. append() :-

l = []
l.append('A')
l.append('B')
l.append('C')
l

['A', 'B', 'C']

l = []
for i in range(101):
    if i%10 == 0:
        l.append(i)

print(l)

[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# 2. insert() :-
    # To insert element ar specified index position

    # If specified index is smaller than min index, then element will be inserted at beginning.

    # If specified index is greater than max index, then element will be inserted at end.

l = [10,20,30,40,50]
l

[10, 20, 30, 40, 50]

id(l)

3050955359232

l.insert(1,70)
l

[10, 70, 20, 30, 40, 50]

id(l)

3050955359232

# l.insert(1 ,70) ---> 70 will insert at position 1

# l[1] = 70 ---> replace value at 1 with 70

l = [10,20,30,40,50]
l

[10, 20, 30, 40, 50]

l.insert(-10,70)
l

[70, 10, 20, 30, 40, 50]

l.insert(100,80)
l

[70, 10, 20, 30, 40, 50, 80]

# # append() vs insert() :-

# append(element) ---> Element will be added in the last position
# insert(index, element) ---> Element will be added in the specified position

# 3. extend() :-
    # l1.extend(l2)
        # All elements present in l2 will be inserted to l1

l1 = [10,20,30,40,50]
l2 = [60,70,80]

print(l1)
print(l2)

for x in l2:
    l1.append(x)
print(l1)

[10, 20, 30, 40, 50]
[60, 70, 80]
[10, 20, 30, 40, 50, 60, 70, 80]

l1 = [10,20,30,40,50]
l2 = [60,70,80]

print(l1)
print(l2)

l1.extend(l2)
print(l1)

[10, 20, 30, 40, 50]
[60, 70, 80]
[10, 20, 30, 40, 50, 60, 70, 80]

# 4. remover() :-
    # remove(element)
    # only first occurence
    # ValueError if not present

l = [10,20,30,40,10,20,50]
l

[10, 20, 30, 40, 10, 20, 50]

l.remove(10)
l

[20, 30, 40, 10, 20, 50]

l.remove(10)
l

[20, 30, 40, 20, 50]

l.remove(60)
l

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[15], line 1
----> 1 l.remove(60)
      2 l

ValueError: list.remove(x): x not in list

l = [10,10,10,10,20,20,30]
x = int(input('Enter Element tot remove:'))

if x in l:
    l.remove(x)
else:
    print('Specified Element not avaialble')

print(l)

[10, 10, 10, 10, 20, 20]

l = [10,10,10,10,20,20,30]
x = int(input('Enter Element tot remove:'))

while True:
    if x in l:
        l.remove(x)
    else:
        break

print(l)

[10, 10, 10, 10, 30]

# 5. pop() :-
    # by default pop() will delete last element and returns that element.

l = [10,10,10,20,20,30]
print(l.pop())
print(l)

30
[10, 10, 10, 20, 20]

l = [10,10,10,20,20,30]
print(l.pop())
print(l.pop())
print(l.pop())
print(l)

30
20
20
[10, 10, 10]

l.pop()

10

l = [10,10,10,20,20,30]

x = l.pop()

x

30

l = [10,10,10]

print(l.pop())
print(l.pop())
print(l.pop())

print(l)

10
10
10
[]

l = [10,10,10]

print(l.pop())
print(l.pop())
print(l.pop())
print(l.pop())

print(l)

10
10
10

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[17], line 6
      4 print(l.pop())
      5 print(l.pop())
----> 6 print(l.pop())
      8 print(l)

IndexError: pop from empty list

l = [10,10,10]

print(l.pop())
print(l.pop())
print(l.pop())
if len(l) != 0:
    print(l.pop())

print(l)

10
10
10
[]

# pop() ---> last element will be deleted
# pop(index) ---> last element will be

l = [10,10,10,20,20,30]

print(l.pop(1))
print(l.pop(1))
print(l.pop(1))

print(l)

10
10
20
[10, 20, 30]

l = [10,20,30,40]
print(l)
i = 0

while i < len(l):
    print(l.pop(i))
    i += 1

print(l)

[10, 20, 30, 40]
10
30
[20, 40]

l = [10,20,30,40]
print(l)
i = 0
n = len(l)

while i < n:
    print('Current index value:', i)
    print('Current n value:', n)
    print('The removed element:', l.pop(i))
    i += 1

print(l)

[10, 20, 30, 40]
Current index value: 0
Current n value: 4
The removed element: 10
Current index value: 1
Current n value: 4
The removed element: 30
Current index value: 2
Current n value: 4

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[34], line 9
      7     print('Current index value:', i)
      8     print('Current n value:', n)
----> 9     print('The removed element:', l.pop(i))
     11     i += 1
     13 print(l)

IndexError: pop index out of range

l = [10,20,30,40]
print(l)

while len(l) != 0:
    print('The removed element:', l.pop(i))

print(l)

[10, 20, 30, 40]
The removed element: 10
The removed element: 20
The removed element: 30
The removed element: 40
[]

# # remove() vs pop() :-

# remove() :-
    # element based removal
    # ValueError, membership operator

# pop() :-
    # index based removaland by default last element will be deleted
    # IndexError

l = [10,20,30,40]
l

[10, 20, 30, 40]

l.pop()

40

l

[10, 20, 30]

l.remove(30)

l

[10, 20]

l.pop(20)

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[44], line 1
----> 1 l.pop(20)

IndexError: pop index out of range

# pop() ---> last element will be deleted
# pop(index) ---> element will be deleted at specified index

# 6. clear() :-
    # to delete all elements

l = [10,20,30,40]
l

[10, 20, 30, 40]

l.clear()

l

[]

l = [10,20,30,40]

print(l)
print(l.clear())
print(l)

[10, 20, 30, 40]
None
[]

# append()
# insert()
# extend()

# remove()
# pop()
# clear()

# Order Elements of the List :-

# 1. reverse() :-

l = [10,20,30,40]

print(l)
l.reverse()
print(l)

[10, 20, 30, 40]
[40, 30, 20, 10]

# 2. sort() :-
    # For numbers: Ascending order
    # For strings: Alphabetic order (ASCII Based)

l = [10,5,15,0]

print(l)
l.sort()
print(l)

[10, 5, 15, 0]
[0, 5, 10, 15]

l = ['sunny', 'bunny', 'vinny', 'pinny', 'chinny']

print(l)
l.sort()
print(l)

['sunny', 'bunny', 'vinny', 'pinny', 'chinny']
['bunny', 'chinny', 'pinny', 'sunny', 'vinny']

l = ['sunny', 'bunny', 'vinny', 'pinny', 'chinny']

print(l)
print(l.sort())
print(l)

['sunny', 'bunny', 'vinny', 'pinny', 'chinny']
None
['bunny', 'chinny', 'pinny', 'sunny', 'vinny']

l = [10,5,15,0]

print(l)
print(l.sort())
print(l)

[10, 5, 15, 0]
None
[0, 5, 10, 15]

l = ['sunny', 'bunny', 10, 'pinny', 20]

print(l)
print(l.sort())
print(l)

['sunny', 'bunny', 10, 'pinny', 20]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[69], line 4
      1 l = ['sunny', 'bunny', 10, 'pinny', 20]
      3 print(l)
----> 4 print(l.sort())
      5 print(l)

TypeError: '<' not supported between instances of 'int' and 'str'

l = ['sunny', 'bunny', 'vinny', 'pinny', 'chinny']

print(l)
print(l.sort(reverse=True))
print(l)

['sunny', 'bunny', 'vinny', 'pinny', 'chinny']
None
['vinny', 'sunny', 'pinny', 'chinny', 'bunny']

# # reverse() vs reversed() :-

# reverse() :-
    # list specific method and won't return anything
    # applicable only for list

# reversed() :-
    # python's inbuilt function and returns reversed object
    # applicable for any sequence

# l.sort() --->

# l.sort(reverse=True) --->

# l.sort(reverse=False) --->

# Aliasing and Cloning :-

# Aliasing :- creating duplicate reference ---> l1 = l2

# Cloning :- creating duplicate list object --->

# Aliasing :-
    # The process of cretaing duplicate refrence variable
    # l2 = l1

# Cloning :-
    # The Process of creating duplicate object
    # Ways to create Cloning :
        # 1. By using slice operator
        # 2. By using copy() method

# Aliasing :-
    # The process of cretaing duplicate refrence variable
    # l2 = l1

l1 = [10,20,30,40]
l2 = l1

print(l1)
print(id(l1))

print(l2)
print(id(l2))

[10, 20, 30, 40]
1435542163200
[10, 20, 30, 40]
1435542163200

l1[1] = 777

print(l1)
print(l2)

[10, 777, 30, 40]
[10, 777, 30, 40]

l2[2] = 888

print(l1)
print(l2)

[10, 777, 888, 40]
[10, 777, 888, 40]

# Cloning :-
    # The Process of creating duplicate object
    # Ways to create Cloning :
        # 1. By using slice operator
        # 2. By using copy() method

l1 = [10,20,30,40]
l2 = l1[:]

print(l1)
print(id(l1))

print(l2)
print(id(l2))

[10, 20, 30, 40]
2546502628992
[10, 20, 30, 40]
2546502573504

l1[1] = 777

print(l1)
print(l2)

[10, 777, 30, 40]
[10, 20, 30, 40]

l1 = [10,20,30,40]
l2 = l1.copy()

print(l1)
print(id(l1))

print(l2)
print(id(l2))

[10, 20, 30, 40]
2546502668224
[10, 20, 30, 40]
2546502553856

l1[1] = 777

print(l1)
print(l2)

[10, 777, 30, 40]
[10, 20, 30, 40]

l1[2] = 888

print(l1)
print(l2)

[10, 777, 888, 40]
[10, 20, 30, 40]

l2[2] = 999

print(l1)
print(l2)

[10, 777, 888, 40]
[10, 20, 999, 40]

# Mathematical Operators for List Object :-

# + operator

a = [10,20,30]
b = [40,50,60]
c = a + b

print(c)

[10, 20, 30, 40, 50, 60]

a = [10,20,30]
b = [40,50,60]
c = a + 40

print(c)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[21], line 3
      1 a = [10,20,30]
      2 b = [40,50,60]
----> 3 c = a + 40
      5 print(c)

TypeError: can only concatenate list (not "int") to list

a = [10,20,30]
b = [40,50,60]
c = a + [40]

print(c)

[10, 20, 30, 40]

# + operator and extend()

# + operator :-
    # both should be list

    # list+list

    # new object will be created and returns that object

# extend() :-
    # one should be list and other can be anything

    # l1.extend(l2)

    # new object won't be created and to the existing object only elements will be be added

a = [10,20,30] + [40,50,60]
print(c)

[10, 20, 30, 40]

a = [10,20,30]
a.extend({'a', 'b', 'c'})
print(a)

[10, 20, 30, 'a', 'c', 'b']

a = [10,20,30]
b = {'a', 'b', 'c'}

c = a + b
print(c)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[30], line 4
      1 a = [10,20,30]
      2 b = {'a', 'b', 'c'}
----> 4 c = a + b
      5 print(c)

TypeError: can only concatenate list (not "set") to list

# * operator :-

x = [10,20,30]
y = x*3
print(y)

[10, 20, 30, 10, 20, 30, 10, 20, 30]

# equality operators(==, !=) :-
    # l1 and l2

    # l1 == l2 returns True

    # 1. The number of elements
    # 2. The order of elements
    # 3. The content of the elements(including case)

x = ['dog', 'cat', 'rat']
y = ['dog', 'cat', 'rat']
z = ['DOG', 'CAT', 'RAT']

x == y

True

x == z

False

x != z

True

# Comparison Operators :-
    # <, >, <=, >=

    # Comparison is always based on first element if first element is same then go for second element

x = [10,10,5]
y = [10,20,30,40,50,60]

x > y

False

x >= y

False

x < y

True

x <= y

True

x = ['dog', 'cat', 'rat']
y = ['dog', 'cat', 'dog']

x > y

True

x >= y

True

x < y

False

x <= y

True

# Membership Operators :-
    # in, not in

x = ['dog', 'cat', 'rat']

'dog' in x

True

'zebra' in x

False

'zebra' not in x

True

# Nested Lists :-

# List inside List

l = [10,20,[30,40]]
l

[10, 20, [30, 40]]

l[0]

10

l[1]

20

l[2]

[30, 40]

l[2][0]

30

l[2][1]

40

l = [10,[20,[30,[40]]]]
l

[10, [20, [30, [40]]]]

l[1][0]

20

l[1][1]

[30, [40]]

l[1][1][0]

30

l[1][1][1]

[40]

l = [[10,20,30],[40,50,60],[70,80,90]]
print(l)

print('Elements by Row Wise:')
for x in l:
    print(x)

print('Elements by Matrix Style:')
for row in l:
    for element in row:
        print(element, end=' ')
    print()

print('Elements by Matrix Style:')
for i in range(len(l)):
    for j in range(len(l[i])):
        print(l[i][j], end=' ')
    print()

[[10, 20, 30], [40, 50, 60], [70, 80, 90]]
Elements by Row Wise:
[10, 20, 30]
[40, 50, 60]
[70, 80, 90]
Elements by Matrix Style:
10 20 30 
40 50 60 
70 80 90 
Elements by Matrix Style:
10 20 30 
40 50 60 
70 80 90 

# List Comprehension :-

# # List Comprehension :-
    # It is very easy and compact way of creating list objects from iterable object(like list, tuple, set, dictionary, range, etc) based on some condition.

    # l = [ expression for item in sequence ]
    # l = [ x for x in range(15) ]

    # l = [ expression for item in sequence if condition ]
    # l = [ 2*item for item in range(1,11) if item%2 == 0 ]

range(10)

range(0, 10)

l = [x for x in range(15)]
l

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

l = [item for item in range(10)]
l

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

l = [item*item for item in range(10)]
l

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

l = [2*item for item in range(10)]
l

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

l = [2*item for item in range(1,11)]
l

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

l = [2*item for item in range(1,11) if item%2==0]
l

[4, 8, 12, 16, 20]

l = [item*item*item for item in range(1,20) if item*item*item%2==0]
l

[8, 64, 216, 512, 1000, 1728, 2744, 4096, 5832]

l = [int(x) for x in input('Enter Multiple Values:').split()]
l

[1, 2, 54, 13, 4, 54, 31, 6, 45]

# Create a lsit with squares of first 10 natural numbers

l = []
for x in range(1,11):
    l.append(x*x)
print(l)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

l = [x*x for x in range(1, 11)]
print(l)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

print([x*x for x in range(1, 11)])

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Create a lsit with squares of first 20 even natural numbers

l = []
for x in range(1, 21):
    if x % 2 == 0:
        l.append(x*x)

print(l)

[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]

l = [ x*x for x in range(1, 21) if x*x % 2 == 0 ]
print(l)

[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]

l = [ x**2 for x in range(1, 21) if x**2 % 2 == 0 ]
print(l)

[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]

words = ['Balaiah', 'Nag', 'Venkatesh', 'Chiranjeevi']

l = [ word[0] for word in words]
print(l)

['B', 'N', 'V', 'C']

num1 = [10, 20, 30, 40]
num2 = [30, 40, 50, 60]

# create a list with numbers which are present in num1 but not in num2

num3 = []
for n in num1:
    if n not in num2:
        num3.append(n)

print(num3)

[10, 20]

num1 = [10, 20, 30, 40]
num2 = [30, 40, 50, 60]

# create a list with numbers which are present in num1 but not in num2

num3 = [ x for x in num1 if x not in num2 ]
print(num3)

[10, 20]

num1 = [10, 20, 30, 40]
num2 = [30, 40, 50, 60]

# create a list with common numbers which are present in both lists

num3 = [ x for x in num1 if x in num2 ]
print(num3)

[30, 40]

s = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG'

words = s.split()
print(words)

['THE', 'QUICK', 'BROWN', 'FOX', 'JUMPS', 'OVER', 'THE', 'LAZY', 'DOG']

l = []
for word in words:
    l.append([word, len(word)])
print(l)

[['THE', 3], ['QUICK', 5], ['BROWN', 5], ['FOX', 3], ['JUMPS', 5], ['OVER', 4], ['THE', 3], ['LAZY', 4], ['DOG', 3]]

l = [ [word, len(word)] for word in words]
print(l)

[['THE', 3], ['QUICK', 5], ['BROWN', 5], ['FOX', 3], ['JUMPS', 5], ['OVER', 4], ['THE', 3], ['LAZY', 4], ['DOG', 3]]

s = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG'

l = [ [word, len(word)] for word in s.split()]
print(l)

[['THE', 3], ['QUICK', 5], ['BROWN', 5], ['FOX', 3], ['JUMPS', 5], ['OVER', 4], ['THE', 3], ['LAZY', 4], ['DOG', 3]]

l = [ [word.lower(), len(word)] for word in s.split()]
print(l)

[['the', 3], ['quick', 5], ['brown', 5], ['fox', 3], ['jumps', 5], ['over', 4], ['the', 3], ['lazy', 4], ['dog', 3]]

l = [ [word.capitalize(), len(word)] for word in s.split()]
print(l)

[['The', 3], ['Quick', 5], ['Brown', 5], ['Fox', 3], ['Jumps', 5], ['Over', 4], ['The', 3], ['Lazy', 4], ['Dog', 3]]

l = [ [word.title(), len(word)] for word in s.split()]
print(l)

[['The', 3], ['Quick', 5], ['Brown', 5], ['Fox', 3], ['Jumps', 5], ['Over', 4], ['The', 3], ['Lazy', 4], ['Dog', 3]]

# Program to display unique vowels present in the given word?
# Example-> 'DURGA'

word = input('Enter any word to Search for vowels:')
print(word)
vowels = ['a', 'e', 'i', 'o', 'u']
found = []

for v in vowels:
    if v in word:
        found.append(v)

print('Unique Vowels Present:', found)

adasfasdfaadsa
Unique Vowels Present: ['a']

word = input('Enter any word to Search for vowels:')
print(word)

found = [ v for v in vowels if v in word]

print('Unique Vowels Present:', found)

aeiojaksdkbvadksfa
Unique Vowels Present: ['a', 'e', 'i', 'o']

l =[1,2,3]

l.extend(10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[43], line 1
----> 1 l.extend(10)

TypeError: 'int' object is not iterable

l.extend('durga')
print(l)

[1, 2, 3, 'd', 'u', 'r', 'g', 'a']

# # Tuple Data Structure :-

# 1. It is exactly same as list exvcept thta it is immutable.
    # Once we creates tuple object, we cannot change its content.
    # It is read only version of list.

# 2. Duplicates are allowed

# 3. Order will be preserved

# 4. index and slicing concepts are applicable

# 5. heterogeneous objects area allowed

# 6. ()

# 7. parenthesis are optional
    # single valued tuple ===> , is manadatory

l = [10, 20, 30, 40]
print(l)
l[0] = 777
print(l)

[10, 20, 30, 40]
[777, 20, 30, 40]

t = (10, 20, 30, 40)
print(t)

(10, 20, 30, 40)

t[0] = 777
print(t)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 t[0] = 777
      2 print(t)

TypeError: 'tuple' object does not support item assignment

t = (10, 20, 10, 'durga', '40')
t

(10, 20, 10, 'durga', '40')

t[0]

10

t[1:4]

(20, 10, 'durga')

t = 10,20,30,40
type(t)

tuple

t = 10,
type(t)

tuple

t = (10)
type(t)

int

t = (10,)
type(t)

tuple

t = ()
type(t)

tuple

# list is mutable where as tuple is immutable
    # facebook/ youtube comments section ---> List

# vendor machines ---> The allowed inputs are always fixed ---> tuple
    # Bank Application
        # account_types: Savings, Current ---> tuple

# Deposit machines..... like Notes are fixed(100, 200, 500, 2000)

# list ---> to access element  l[10] ---> 10ns
# tuple ---> to access element  t[10] ---> 6ns

# 100 elements ---> list ---> 100Bytes
# 100 elements ---> tuple ---> 60Bytes

import sys

l = [10, 20, 30, 40, 50, 60, 70, 80, 90]
t = (10, 20, 30, 40, 50, 60, 70, 80, 90)

print(sys.getsizeof(l))
print(sys.getsizeof(t))

136
112

# A sequence of elements
    # order is important
    # duplicates are allowed

# # Tuple Creation :-

t = ()
type(t)

tuple

# list ---> tuple
# set ---> tuple

# By Using tuple() Function :-

l = [10, 20, 30]
print(l)

t = tuple(l)
print(t)

[10, 20, 30]
(10, 20, 30)

r = range(10)
t = tuple(r)
print(t)

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# eval() :-

t = eval(input('Enter tuple Value:'))
print(type(t))
print(t)

<class 'tuple'>
(4164564, 121, 54)

l = eval(input('Enter List Value:'))
print(type(l))
print(l)

<class 'tuple'>
(54, 5415, 5465, 415)

# # Accessing Elements of Tuple :-

# by using index
# by using slice opeartor

t = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
t

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

t[0]

10

t[5]

60

t[1:8:2]

(20, 40, 60, 80)

# Tuple vs Immutable :-

# Tuples are immutable

t = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
t

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

t[0] = 777

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[29], line 1
----> 1 t[0] = 777

TypeError: 'tuple' object does not support item assignment

# Mathematical Operators :-

# +, *, ==, !=, >, >=, <, <=

t1 = (10, 20, 30)
t2 = (40, 50, 60)

print(t1)
print(t2)

(10, 20, 30)
(40, 50, 60)

t3 = t1 + t2
print(t3)

(10, 20, 30, 40, 50, 60)

t4 = t1 * 3
print(t4)

(10, 20, 30, 10, 20, 30, 10, 20, 30)

# Important Functions and method related to Tuple :-

# 1. len()
# 2. count()
# 3. index()

# 4. sorted()
# 5. min()
# 6. max()

t = (10, 20, 30)
len(t)

3

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.count(10)

3

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.index(10)

0

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.index(40)

3

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.index(52)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[66], line 2
      1 t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
----> 2 t1.index(52)

ValueError: tuple.index(x): x not in tuple

l = [0, 20, 5, 15, 10]
l.sort()
print(l)

[0, 5, 10, 15, 20]

t = (0, 20, 5, 15, 10)
t.sort()
print(t)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[51], line 2
      1 t = (0, 20, 5, 15, 10)
----> 2 t.sort()
      3 print(t)

AttributeError: 'tuple' object has no attribute 'sort'

t = (0, 20, 5, 15, 10)
l1 = tuple(sorted(t))
print(l1)

(0, 5, 10, 15, 20)

t = (0, 20, 5, 15, 10)
l1 = tuple(sorted(t, reverse=True))
print(l1)

(20, 15, 10, 5, 0)

t = (0, 20, 5, 15, 10)
print(t)
print(min(t))

(0, 20, 5, 15, 10)
0

t = (0, 20, 5, 15, 10)
print(t)
print(max(t))

(0, 20, 5, 15, 10)
20

# sort() vs sorted() :-

# sort() is list specific method.
    # Applicable only for list
    # It won't create new list and in the existing list only sorting will be happening
    # return type ---> None

# sorted() is general purpose python's inbuilt function.
    # Applicable for any sequence
    # A new lsit object will be created always
    # return type ---> List

l = [0, 20, 5, 15, 10]
print("Before Sorting:", l)
print("Before Sorting Address:", id(l))

l.sort()
print("After Sorting:", l)
print("After Sorting Address:", id(l))

Before Sorting: [0, 20, 5, 15, 10]
Before Sorting Address: 1986209712704
After Sorting: [0, 5, 10, 15, 20]
After Sorting Address: 1986209712704

l = [0, 20, 5, 15, 10]
print("Before Sorting:", l)
print("Before Sorting Address:", id(l))

l1 = sorted(l)
print("After Sorting:", l1)
print("After Sorting Address:", id(l1))

Before Sorting: [0, 20, 5, 15, 10]
Before Sorting Address: 1986209665280
After Sorting: [0, 5, 10, 15, 20]
After Sorting Address: 1986209667392

print(l)

[0, 5, 10, 15, 20]

t1 = (10, 20, 30, 40)
t2 = (10, 20, 30, 40)
t3 = (20, 30, 40, 10)

print(t1)
print(t2)
print(t3)

(10, 20, 30, 40)
(10, 20, 30, 40)
(20, 30, 40, 10)

t1 == t2

True

t1 == t3

False

t1 != t3

True

t1 < t2

False

t1 < t3

True

# Tuple Packing and Unpacking :-

# Tuple Packing :-
    # t = a, b, c, d ===> pack 4 values into a single tuple

# Tuple Unpacking :-
    # a, b, c, d = t ===> unpack 4 values from a tuple t and assign to a, b, c, d

a = 10
b = 20
c = 30
d = 40

t = a, b, c, d
print(t)

(10, 20, 30, 40)

t = (10, 20, 30, 40)
a, b, c, d = t
print(a, b, c, d)

10 20 30 40

t = (10, 20, 30, 40)
a, b, c, d, e = t
print(a, b, c, d, e)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[87], line 2
      1 t = (10, 20, 30, 40)
----> 2 a, b, c, d, e = t
      3 print(a, b, c, d, e)

ValueError: not enough values to unpack (expected 5, got 4)

t = (10, 20, 30, 40)
a, b, c = t
print(a, b, c)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[88], line 2
      1 t = (10, 20, 30, 40)
----> 2 a, b, c = t
      3 print(a, b, c)

ValueError: too many values to unpack (expected 3)

# *c ---> a group of values(tuple)

# **c ---> a group of key-value pairs(dictionary)

t = (10, 20, 30, 40, 50, 60, 70)
a, b, *c = t

print(a)
print(b)
print(c)

10
20
[30, 40, 50, 60, 70]

# *args ---> variable mumber of arguments
# **kwargs ---> variable mumber of keyword arguments

l = [x * x for x in range(1, 6)]
print(type(l))
print(l)

<class 'list'>
[1, 4, 9, 16, 25]

t = (x * x for x in range(1, 6))
print(type(t))
print(t)

<class 'generator'>
<generator object <genexpr> at 0x000001CE735B45F0>

# Difference b/w List and Tuple :-

# # List :-

    # List is
        # [10, 20, 30, 40]

    # 1. Mutable

    # 2. performance wise, memory wise list is not up to the mark

    # 3. comprehension concept --> list

    # 4. packing

    # 5. List object --> non hashable/ unhashable object
        # We cannot use as key in dictionary


# # Tuple :-

    # Tuple is
        # (10, 20, 30, 40)  or   10, 20, 30, 40

    # 1. Immutable

    # 2. performance wise, memory wise tuple is up to the mark

    # 3. comprehension concept --> not applicable

    # 4. packing and unpacking

    # 5. Tuple object --> hashable object
        # We can use as key in dictionary

d = {[10, 20, 30, 40]: "durga"}
print(d)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[102], line 1
----> 1 d = {[10, 20, 30, 40]: "durga"}
      2 print(d)

TypeError: unhashable type: 'list'

d = {(10, 20, 30, 40): "durga"}
print(d)

{(10, 20, 30, 40): 'durga'}

# WAP to take tuple numbers from keyboard and print ist sum and average?

t = eval(input("Enter Tuple Numbers:"))
print(t)

l = len(t)
sum = 0
for n in t:
    sum = sum + n

print("Sum:", sum)
print('Average:',sum/l)

(1321, 63156, 43654, 63465)
Sum: 171596
Average: 42899.0

# List
# Tuple

    # Order will be preserved
    # Duplicates are allowed

# # Set Data Structure :-

# Order is not important
# Duplicates objects are not allowed i.e. we required to hold only unique objects.

# sms message.about duragasoftonline.com courses offer.
# 1 lakh mobile numbers
# duplicates are not allowed ---> we use set

# # Set Properties :-

    # Order is not Preserved.

    # indexing and slicing concepts are not applicable.

    # Duplicates Objects are not allowed.

    # heterogeneous objects are allowed.

    # mutable and growable

    # by using {} we can represent set of elements

    # mathematical operations like union, intersection, difference etc.

s = {10, "durag", 30}
s

{10, 30, 'durag'}

s = {10, "durag", 30, 10, 10, 20}
s

{10, 20, 30, 'durag'}

# Creation of Set Objects :-

# 1. s = {10, 20, 30, 40}

# 2. s = set(any sequence)
    # s = set(list)
    # s = set(range)

# 3. By using eval()

s = {10, 20, 30, 40}
s

{10, 20, 30, 40}

s = {20, 40, 30, 10}
s

{10, 20, 30, 40}

l = [20, 10, 30, 10, 50, 10, 10, 40]
s = set(l)
print(s)

{40, 10, 50, 20, 30}

l = (20, 10, 30, 10, 50, 10, 10, 40)
s = set(l)
print(s)

{40, 10, 50, 20, 30}

s = set(range(10))
print(s)

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

d = {100: "durga", 200: "ravi"}
s = set(d)
print(s)

{200, 100}

s = set('mississippi')
print(s)

{'s', 'i', 'p', 'm'}

s = eval(input('Any set of Elements:'))
print(s)
print(type(s))

{546, 3435, 46, 63463}
<class 'set'>

# # Empty set Objects :-

# s = {} ===> dict but not set

s = {}
type(s)

dict

s = set()
type(s)

set

# Important Methods and Functions related to Set :-

# 1. s.add(x) ---> To add an element to the set

# 2. s.update(x, y, z)
    # To add multiple items to the set
    # x, y, z are not individual objects, must be sequences

s = set()
print(s)

s.add(70)
s.add(50)
s.add(90)
s.add('ram')
s.add(50)

print(s)

set()
{50, 90, 70, 'ram'}

s = set()
s.update(range(1, 6))
print(s)

{1, 2, 3, 4, 5}

s = set()
s.update(range(1, 6), range(6, 11), "durga", "solutions")
print(s)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'r', 'd', 'n', 'l', 's', 'u', 'g', 'a', 'i', 't', 'o'}

s = set()
s.update(10)
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[39], line 2
      1 s = set()
----> 2 s.update(10)
      3 s

TypeError: 'int' object is not iterable

s = set()
s.update('10')
s

{'0', '1'}

# add() vs update() :-

# add() ---> to add single item

# update() ---> to add multiple items from the given sequence

s = set('mississippi')
s

{'i', 'm', 'p', 's'}

s = set()
s.update(10,)
print(s)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[44], line 2
      1 s = set()
----> 2 s.update(10,)
      3 print(s)

TypeError: 'int' object is not iterable

s = set()
s.update((10,))
print(s)

{10}

s = set()
s

set()

s.add(10)
s

{10}

s.add(10, 20, 30)
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[50], line 1
----> 1 s.add(10, 20, 30)
      2 s

TypeError: set.add() takes exactly one argument (3 given)

s.update(10)
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[51], line 1
----> 1 s.update(10)
      2 s

TypeError: 'int' object is not iterable

s.update(range(1, 11), range(11, 20))
s

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}

s.add(range(1, 10))
s

{1,
 10,
 11,
 12,
 13,
 14,
 15,
 16,
 17,
 18,
 19,
 2,
 3,
 4,
 5,
 6,
 7,
 8,
 9,
 range(1, 10)}

# In set every element should be hashable.

# List is not hashable but tuple is hashable

s = set()
s.add([10, 20, 30])
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[57], line 2
      1 s = set()
----> 2 s.add([10, 20, 30])
      3 s

TypeError: unhashable type: 'list'

s = set()
s.add((10, 20, 30))
s

{(10, 20, 30)}

s = set()
s.add(range(0, 9))
s

{range(0, 9)}

s = set()
s.update(range(0, 9))
s

{0, 1, 2, 3, 4, 5, 6, 7, 8}

l = [10,20,30]
print(l)

l.append(40)
print(l)

l.insert(1, 50)
print(l)

[10, 20, 30]
[10, 20, 30, 40]
[10, 50, 20, 30, 40]

s.add(10)
# Internally PVM will store elements of set based on hashing.

# str is hashable type
# int is hashable type

# list is not hashable

s = set()
s.add(10)
s

{10}

s = set()
s.add(10.5)
s

{10.5}

s = set()
s.add("durga")
s

{'durga'}

s = set()
s.add([10, 20, 30])
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[66], line 2
      1 s = set()
----> 2 s.add([10, 20, 30])
      3 s

TypeError: unhashable type: 'list'

s = set()
s.add((10, 20, 30))
s

{(10, 20, 30)}

# If our frequent operation is search then set is the best choice.

# s = set(list) ---> in this we won;t get any error because we are not adding list object directly, we are adding elements present in the list.

# s.update(list) ---> in this we won;t get any error because we are not adding list object directly, we are adding elements present in the list.

# s.add(list) ---> we are getting error becuase we are adding list object directly to the set.

s = set()
s.add([10, 20, 30]) # we are adding list object to the set
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[70], line 2
      1 s = set()
----> 2 s.add([10, 20, 30])
      3 s

TypeError: unhashable type: 'list'

s = set()
s.update([10, 20, 30])  # we are adding elements present in the list to the set
s

{10, 20, 30}

s = set([10, 20, 30])
s

{10, 20, 30}

s = set()
s.update([10, 20, [30, 40]])
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[73], line 2
      1 s = set()
----> 2 s.update([10, 20, [30, 40]])
      3 s

TypeError: unhashable type: 'list'

# 3. remove() elements :-

# s.pop() ---> it removes and returns some random element from the set

s = {10, 50, 40, 20, 5, 0, 5}
print(s)

print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())

{0, 50, 20, 5, 40, 10}
0
50
20
5
40

s = {10, 50, 40, 20, 5, 0, 5}
print(s)

print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())

{0, 50, 20, 5, 40, 10}
0
50
20
5
40
10

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[83], line 10
      8 print(s.pop())
      9 print(s.pop())
---> 10 print(s.pop())

KeyError: 'pop from an empty set'

s = {10, 50, 40, 20, 5, 0, 5}
print(s)

print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
if len(s) != 0:
    print(s.pop())

{0, 50, 20, 5, 40, 10}
0
50
20
5
40
10

s = {10, 20, 30, 10, 20, 30, 40, 50, 60, 70, 80, 10, 20, 30, 40, 50}

while len(s) != 0:
    n = s.pop()
    print("Sending SMS to Mobile Number:", n)

Sending SMS to Mobile Number: 70
Sending SMS to Mobile Number: 40
Sending SMS to Mobile Number: 10
Sending SMS to Mobile Number: 80
Sending SMS to Mobile Number: 50
Sending SMS to Mobile Number: 20
Sending SMS to Mobile Number: 60
Sending SMS to Mobile Number: 30

# 4. remove(x) :-
    # It removes the specified element
    # If the specified element is not available then we will get KeyError

s = {10, 20, 30}
s.remove(20)
print(s)

{10, 30}

s = {10, 20, 30}
s.remove(40)
print(s)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[91], line 2
      1 s = {10, 20, 30}
----> 2 s.remove(40)
      3 print(s)

KeyError: 40

s = {10, 20, 30}
if 40 in s:
    s.remove(40)
print(s)

{10, 20, 30}

# 5. s.discard(x) :-
    # It removes the specified element
    # If the specified element is not available then we won't get any Error.

s = {10, 20, 30}
s.discard(40)
print(s)

{10, 20, 30}

s = {10, 20, 30}

s.discard(40)
s.discard(20)
s.discard(90)
s.discard(70)
s.discard(30)

print(s)

{10}

# remove(x) and discard(x) and pop() :-

# 6. s.clear() :-
    # To remove all elements from the set

s = {10, 20, 50, 560, 54, 40, 30}
print(s)

s.clear()
print(s)

{560, 50, 20, 54, 40, 10, 30}
set()

# s1 = s ===> aliasing	    duplicate reference variable creation

# s1 = s.copy() ===> cloning    duplicate set object creation

s = {10, 20, 30}
s1 = s

print(id(s))
print(id(s1))

2551548162144
2551548162144

s = {10, 20, 30}
s1 = s.copy()

print(id(s))
print(id(s1))

2551548164160
2551548159456

# Mathematical Operations on the Set :-

# 1. union()    ---> A | B
# 2. intersection() ---> A & B
# 3. difference()   ---> A - B
# 4. symmetric_difference() ---> A ^ B

s1 = {1, 2, 3}
s2 = {4, 5, 6}

print(s1)
print(s2)

{1, 2, 3}
{4, 5, 6}

s3 = s1 + s2
print(s3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[3], line 1
----> 1 s3 = s1 + s2
      2 print(s3)

TypeError: unsupported operand type(s) for +: 'set' and 'set'

s3 = s1 * s2
print(s3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[4], line 1
----> 1 s3 = s1 * s2
      2 print(s3)

TypeError: unsupported operand type(s) for *: 'set' and 'set'

# 1. union() :-
    # x.union(y) ===> It returns all elements present in both x and y
    # x | y

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.union(y))
print(x | y)

print(y.union(x))
print(y | x)

{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}

# 2. intersection() :-
    # common elements
    # x.intersection(y)
    # x & y

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.intersection(y))
print(x & y)

print(y.intersection(x))
print(y & x)

{40, 30}
{40, 30}
{40, 30}
{40, 30}

# 3. difference() :-
    # x.difference(y)
    # x - y

    # The elements present in x but not in y

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.difference(y))
print(x - y)

print(y.difference(x))
print(y - x)

{10, 20}
{10, 20}
{50, 60}
{50, 60}

# 3. symmetric_difference() :-
    # x.symmetric_difference(y)
    # x ^ y

    # The elements present in either x or y butu not in both

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.symmetric_difference(y))
print(x ^ y)

print(y.symmetric_difference(x))
print(y ^ x)

{10, 50, 20, 60}
{10, 50, 20, 60}
{10, 50, 20, 60}
{10, 50, 20, 60}

# Membership Operator :-

# in, not in

x = {10, 20, 30, 40}
print(x)

{40, 10, 20, 30}

print(10 in x)

True

print(50 in x)

False

print(50 not in x)

True

# Comprehension :-

# list ---> applicable
# tuple ---> not applicable
# set ---> applicable

s = {x * x for x in range(1, 6)}
print(type(s))
print(s)

<class 'set'>
{1, 4, 9, 16, 25}

s = {2**x for x in range(1, 6)}
print(type(s))
print(s)

<class 'set'>
{32, 2, 4, 8, 16}

s1 = {10, 20, 30}
s2 = {20, 30, 10}

print(s1 is s2)
print(s1 == s2)

False
True

s1 = {10, 20, 30}
s2 = {10, 20, 30}

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873356064
2947873352704

s1 = {10, 20, 30}
s2 = s1

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

True
True
2947873356064
2947873356064

s1 = {10, 20, 30}
s2 = s1.copy()

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873357408
2947873352704

s1 = [10, 20, 30]
s2 = [10, 20, 30]

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873771776
2947873774592

s1 = (10, 20, 30)
s2 = (10, 20, 30)

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873830336
2947873799232

# For set order is not important
# indexing and slicing concepts are not applicable

s = {10, 20, 30}
print(s)

{10, 20, 30}

s[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[16], line 1
----> 1 s[0]

TypeError: 'set' object is not subscriptable

s = [10, 20, 30]
print(id(s))

s = [20, 30, 10]
print(id(s))

2947873665088
2947879642112

# WAP to delete duplicates present in the list?

l = eval(input("Enter a list of values:"))
print(l)

s = set(l)
print(s)

[4646, 64, 546, 46, 464, 46]
{64, 546, 4646, 46, 464}

l = eval(input("Enter a list of values:"))
print(l)

l1 = []
for x in l:
    if x not in l1:
        l1.append(x)

print(l1)

[46, 22, 21, 12, 12, 45, 45, 65, 65, 85, 95, 85, 95]
[46, 22, 21, 12, 45, 65, 85, 95]

# # Dictionary Data Structure :-

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

# keys ---> 100, 200, 300
# values ---> 'durga', 'ravi', 'shiva'

# duplicate keys are not allowed, but values can be duplicated.
    # If we are trying to add key-value pair but key already present, then old value will be replaced with new value.

# order is not applicable and all elements will be inserted based on hash of keys.

# indexing and slicing concepts are not applicable.

# for keys and values we can take heterogeneous objects.

# dict is mutable.

# dict is growable.

d = {100: "durga", "ravi": 200, True: "shiva"}
print(d)

{100: 'durga', 'ravi': 200, True: 'shiva'}

# How to Create Dictionary :-

# If we don't know data :-

d = {}
print(type(d))

# or

d = dict()
print(type(d))

<class 'dict'>
<class 'dict'>

# d[key] = value    ===>
    # The provided key-valule pair will be added to the dict
    # If the dspecified key is already available then old value will be replaced with new value.

# d = {key1:value1, key2:value2, key3:value3}

d = {}
print(d)

d[100] = "durga"
d[200] = "shiva"
d[300] = "ravi"

print(d)

{}
{100: 'durga', 200: 'shiva', 300: 'ravi'}

d[100] = "pavan"
print(d)

{100: 'pavan', 200: 'shiva', 300: 'ravi'}

d = {1, 2, 3 : 'a', 'b', 'c'}

  Cell In[18], line 1
    d = {1, 2, 3 : 'a', 'b', 'c'}
                 ^
SyntaxError: invalid syntax

# Access Data From the Dictionary :-

# By using key we can access the corresponding value.

d = {100: "pavan", 200: "shiva", 300: "ravi"}
print(d)

{100: 'pavan', 200: 'shiva', 300: 'ravi'}

print(d[200])

shiva

print(d[100])

pavan

print(d[500])

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[23], line 1
----> 1 print(d[500])

KeyError: 500

# Using value can we get key?

d = {100: "pavan", 200: "shiva", 300: "ravi"}
print(d)

key = int(input("Enter key to find corresponding value:"))
if key in d:
    print(d[key])
else:
    print("Specified key not available:", key)

{100: 'pavan', 200: 'shiva', 300: 'ravi'}
Specified key not available: 352

d = {100: "pavan", 200: "shiva", 300: "ravi"}
print(d)
print(d[200])

{100: 'pavan', 200: 'shiva', 300: 'ravi'}
shiva

# Quest: WAP to enter name and marks in a dictionary and display information on the screen?

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    if option.lower() == "n":
        break
    elif option.lower() == 'y':
        continue
    else:
        print('Invalid Input to Continue')
        break

print(d)

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Invalid Input to Continue
{'asdadf': '54', 'amsdka': '95', 'safas': '12', 'dsafads': '56'}

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    while True:
        if option.lower() == "n":
            option = "n"
            break
        elif option.lower() == "y":
            option = "y"
            break
        else:
            option = input("Your Entered option is Invalid, Please Choose Correct option [Y|N]:")
    if option == "n":
        break

print(d)

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
{'ram': '95', 'han': '85', 'nksdnf': "52'", 'dsaf': '5654'}

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    while True:
        if option.lower() in ["y", "n"]:
            break
        else:
            option = input(
                "Your Entered option is Invalid, Please Choose Correct option [Y|N]:"
            )
    if option == "n":
        break

print(d)

Student record inserted Successfully
Student record inserted Successfully
{'ad': '54', 'asd': '5'}

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    while True:
        if option.lower() not in ["y", "n"]:
            option = input(
                "Your Entered option is Invalid, Please Choose Correct option [Y|N]:"
            )
        else:
            break
    if option == "n":
        break

print(d)
for x in d:
    print("{}\t{}".format(x, d[x]))

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
{'ram': '52', 'shyam': '95', 'barry': '96'}
ram	52
shyam	95
barry	96

d = {}
while len(d) < 5:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

print(d)
for x in d:
    print("{}\t{}".format(x, d[x]))

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
{'ram': '10', 'shyam': '30', 'ravi': '65', 'harry': '94', 'barry': '82'}
ram	10
shyam	30
ravi	65
harry	94
barry	82

# Update Dictionary :-

# d = {}

# d[key] = value
    # If the specified key is not already available, then key-value will be added.

    # If the specified key is already available, then olde value will be replaced with new value.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

d[400] = "pavan"
print(d)

d[200] = "harry"
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{100: 'durga', 200: 'ravi', 300: 'shiva', 400: 'pavan'}
{100: 'durga', 200: 'harry', 300: 'shiva', 400: 'pavan'}

# Delete Elements from Dictionary :-

# del d[key]
    # If the specified key is available, then total entry will be deleted.

    # If the specified key is not available, then we will get KeyError.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

del d[100]
print(d)

{200: 'ravi', 300: 'shiva'}

del d[400]
print(d)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[16], line 1
----> 1 del d[400]
      2 print(d)

KeyError: 400

if 400 in d:
    del d[400]
print(d)

{200: 'ravi', 300: 'shiva'}

# To remove all the entries :-

    # d.clear()

    # del d

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

d.clear()
print(d)

{}

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

del d
print(d)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[25], line 2
      1 del d
----> 2 print(d)

NameError: name 'd' is not defined

# Important Methods and Functions related to Dictionary :-

# 1. dict() :-

d = dict()
print(d)
print(type(d))

{}
<class 'dict'>

d = dict({100: "ram", 200: "durga"})
print(d)
print(type(d))

{100: 'ram', 200: 'durga'}
<class 'dict'>

# [(100, 'durga'), (200, 'shiva'), (300, 'ravi')]   ---> List of Tuples

d = dict([(100, "durga"), (200, "shiva"), (300, "ravi")])
print(d)
print(type(d))

{100: 'durga', 200: 'shiva', 300: 'ravi'}
<class 'dict'>

d = dict(((100, "durga"), (200, "shiva"), (300, "ravi")))
print(d)
print(type(d))

{100: 'durga', 200: 'shiva', 300: 'ravi'}
<class 'dict'>

d = dict([[100, "durga"], [200, "shiva"], [300, "ravi"]])
print(d)
print(type(d))

{100: 'durga', 200: 'shiva', 300: 'ravi'}
<class 'dict'>

d = dict({[100, "durga"], [200, "shiva"], [300, "ravi"]})
print(d)
print(type(d))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[35], line 1
----> 1 d = dict({[100, "durga"], [200, "shiva"], [300, "ravi"]})
      2 print(d)
      3 print(type(d))

TypeError: unhashable type: 'list'

d = dict({(100, "durga"), (200, "shiva"), (300, "ravi")})
print(d)
print(type(d))

{300: 'ravi', 100: 'durga', 200: 'shiva'}
<class 'dict'>

# 2. len() :-
    # returns the number of items in the dictionary
        # item ---> key-value pair

d = dict({(100, "durga"), (200, "shiva"), (300, "ravi")})
print(d)
print(len(d))

{300: 'ravi', 100: 'durga', 200: 'shiva'}
3

# 3. get(key) :-

    # returns the corresponding value.
    # If specified key not available then None

# d[key]    ---> KeyError

# d.get(key)    ---> None
# d.get(key, default_value)

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.get(100))

durga

print(d.get(200))

ravi

print(d.get(900))

None

print(d.get(900, 'no value'))

no value

# 5. pop() :-

    # d.pop(key)
        # remove item(key-value pair) associated with the specified key and returns the corresponding value.

        # If the specified key not already available then we will get KeyError.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.pop())
print(d)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 print(d.pop())
      2 print(d)

TypeError: pop expected at least 1 argument, got 0

print(d.pop(200))
print(d)

ravi
{100: 'durga', 300: 'shiva'}

print(d.pop(500))
print(d)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[7], line 1
----> 1 print(d.pop(500))
      2 print(d)

KeyError: 500

# 6. popitem() :-

    # d.popitem()
        # It will remove an arbitrary item from the dict and returns it.

        # If the dict is empty then we get KeyError

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.popitem())
print(d)

(300, 'shiva')
{100: 'durga', 200: 'ravi'}

print(d.popitem())
print(d)

(200, 'ravi')
{100: 'durga'}

print(d.popitem())
print(d)

(100, 'durga')
{}

print(d.popitem())
print(d)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[13], line 1
----> 1 print(d.popitem())
      2 print(d)

KeyError: 'popitem(): dictionary is empty'

# 7. keys() :-

    # d.keys()

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1
print(d)

{'A': 100, 'B': 110, 'C': 120, 'D': 130, 'E': 140, 'F': 150, 'G': 160, 'H': 170, 'I': 180, 'J': 190, 'K': 200, 'L': 210, 'M': 220, 'N': 230, 'O': 240, 'P': 250, 'Q': 260, 'R': 270, 'S': 280, 'T': 290, 'U': 300, 'V': 310, 'W': 320, 'X': 330, 'Y': 340, 'Z': 350}

while len(d) != 0:
    print('Processing item:', d.popitem())

Processing item: ('Z', 350)
Processing item: ('Y', 340)
Processing item: ('X', 330)
Processing item: ('W', 320)
Processing item: ('V', 310)
Processing item: ('U', 300)
Processing item: ('T', 290)
Processing item: ('S', 280)
Processing item: ('R', 270)
Processing item: ('Q', 260)
Processing item: ('P', 250)
Processing item: ('O', 240)
Processing item: ('N', 230)
Processing item: ('M', 220)
Processing item: ('L', 210)
Processing item: ('K', 200)
Processing item: ('J', 190)
Processing item: ('I', 180)
Processing item: ('H', 170)
Processing item: ('G', 160)
Processing item: ('F', 150)
Processing item: ('E', 140)
Processing item: ('D', 130)
Processing item: ('C', 120)
Processing item: ('B', 110)
Processing item: ('A', 100)

print(d)

{}

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

k = d.keys()
print(type(k))
print(k)

for k1 in k:
    print(k1)

<class 'dict_keys'>
dict_keys(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'])
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

for k1 in d.keys():
    print(k1)

A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

# 8. values() :-

    # d.values()

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

print(d.values())

dict_values([100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350])

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

print(d.values())
for v in d.values():
    print(v)

dict_values([100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350])
100
110
120
130
140
150
160
170
180
190
200
210
220
230
240
250
260
270
280
290
300
310
320
330
340
350

d = {100: "durga", 200: "durga", 300: "durga"}
for v in d.values():
    print(v)

durga
durga
durga

# 9. items() :-

    # d.items()
        # item ---> key-value pair

d = {100: "durga", 200: "ravi", 300: "shiva"}

i = d.items()

print(type(i))
print(i)

<class 'dict_items'>
dict_items([(100, 'durga'), (200, 'ravi'), (300, 'shiva')])

d = {100: "durga", 200: "ravi", 300: "shiva"}

for x in d.items():
    print(x)

(100, 'durga')
(200, 'ravi')
(300, 'shiva')

d = {100: "durga", 200: "ravi", 300: "shiva"}

for k in d.keys():
    print("Key:", k)

for v in d.values():
    print("Value:", v)

for k, v in d.items():
    print("{}:{}".format(k, v))

Key: 100
Key: 200
Key: 300
Value: durga
Value: ravi
Value: shiva
100:durga
200:ravi
300:shiva

# 10. setdefault() :-

    # d.setdefault(k, v)
        # If the specified key available, then it returnsthe corresponding value.

        # If the specified key not available, then the provided key-value pair will be added as a new item to the dictionary.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.setdefault(100, "sunny"))
d.setdefault(100, "sunny")

print(d)

durga
{100: 'durga', 200: 'ravi', 300: 'shiva', 500: 'bunny'}

print(d.setdefault(500, "bunny"))
d.setdefault(500, "bunny")

print(d)

bunny
{100: 'durga', 200: 'ravi', 300: 'shiva', 500: 'bunny'}

# 11. update() :-

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = {400: "sunny", 500: "bunny", 600: "harry"}

print(d1)
print(d2)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{400: 'sunny', 500: 'bunny', 600: 'harry'}

d1.update(d2)
print(d1)

{100: 'durga', 200: 'ravi', 300: 'shiva', 400: 'sunny', 500: 'bunny', 600: 'harry'}

print(d2)

{400: 'sunny', 500: 'bunny', 600: 'harry'}

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = {400: "sunny", 500: "bunny", 100: "harry"}

print(d1)
print(d2)

d1.update(d2)
print(d1)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{400: 'sunny', 500: 'bunny', 100: 'harry'}
{100: 'harry', 200: 'ravi', 300: 'shiva', 400: 'sunny', 500: 'bunny'}

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = {400: "sunny", 500: "bunny", 100: "harry"}

print(d1)
print(d2)

d1.update(d2)
d2.update(d1)

print(d1)
print(d2)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{400: 'sunny', 500: 'bunny', 100: 'harry'}
{100: 'harry', 200: 'ravi', 300: 'shiva', 400: 'sunny', 500: 'bunny'}
{400: 'sunny', 500: 'bunny', 100: 'harry', 200: 'ravi', 300: 'shiva'}

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1.copy()

print(id(d1))
print(id(d2))

1543898304192
1543899138368

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1

print(id(d1))
print(id(d2))

1543892330624
1543892330624

# d2 = d1   ===> duplicate reference variable and aliasing
# d2 = d1.copy()    ===> duplicate object and cloning

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1.copy()

print(id(d1))
print(id(d2))

print(d1 is d2)

1543898481920
1543892379136
False

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1

print(id(d1))
print(id(d2))

print(d1 is d2)

1543898489856
1543898489856
True

# 1. dict()
# 2. len()
# 3. clear()
# 4. get()
    # d.get(key)
    # d.get(key, default_value)
# 5. pop()
# 6. popitem()
# 7. keys()
# 8. values()
# 9. items()
# 10. setdefault()
# 11. update()
# 12. copy()

# d[key] = value
# del d[key]

# Ques: WAP to take dictionary from the keyboard and print the sum of values?

d = eval(input("Enter Dictionary:"))
print(d)
sum(d.values())

print("The Sum:", sum(d.values()))

{'a': 10, 'b': 20, 'v': 50}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[72], line 3
      1 d = eval(input("Enter Dictionary:"))
      2 print(d)
----> 3 sum(d.values())
      5 print("The Sum:", sum(d.values()))

TypeError: 'int' object is not callable

d = eval(input("Enter Dictionary:"))
print(d)
sum = 0
for v in d.values():
    sum = sum + v

print("The Sum:", sum)

The Sum: 60

# Ques: WAP to find the number of occurreneces of each letter present in the given string?

s = input("Enter any word:")
print(s)

d = {}
for ch in s:
    if ch in d:
        d[ch] = d[ch] + 1
    else:
        d[ch] = 1

print(d)

mississippi
{'m': 1, 'i': 4, 's': 4, 'p': 2}

s = input("Enter any word:")
print(s)

d = {}
for ch in s:
    d[ch] = d.get(ch, 0) + 1

print(d)

for k, v in d.items():
    print("{} occurs {} times".format(k, v))

mississippi
{'m': 1, 'i': 4, 's': 4, 'p': 2}
m occurs 1 times
i occurs 4 times
s occurs 4 times
p occurs 2 times

s = input("Enter any word:")
print(s)

d = {}
for ch in s:
    d[ch] = d.get(ch, 0) + 1

print(d)

for k, v in sorted(d.items()):
    print("{} occurs {} times".format(k, v))

mississippi
{'m': 1, 'i': 4, 's': 4, 'p': 2}
i occurs 4 times
m occurs 1 times
p occurs 2 times
s occurs 4 times

s = input("Enter any word:")
print(s)
vowels = {'a','e','i','o','u'}

d = {}
for ch in s:
    if ch in vowels:
        d[ch] = d.get(ch, 0) + 1

print(d)

for k, v in sorted(d.items()):
    print("{} occurs {} times".format(k, v))

missipkdanskbfked vm,asd kjcvvhadsukc shad cadsjvgcjakevld jds
{'i': 2, 'a': 6, 'e': 2, 'u': 1}
a occurs 6 times
e occurs 2 times
i occurs 2 times
u occurs 1 times

# # Merging of Collections :-

l1 = [10, 20, 30]
l2 = [40, 50, 60]

l3 = l1 + l2
print(l3)

[10, 20, 30, 40, 50, 60]

t1 = (10, 20, 30)
t2 = (40, 50, 60)

t3 = t1 + t2
print(t3)

(10, 20, 30, 40, 50, 60)

# List and Tuple ---> Apply
# Set and Dictionary ---> Not Apply

l1 = [10, 20, 30]
l2 = [40, 50, 60]

l3 = [*l1, *l2]
print(l3)

[10, 20, 30, 40, 50, 60]

l1 = (10, 20, 30)
l2 = (40, 50, 60)

l3 = (*l1, *l2)
print(l3)

(10, 20, 30, 40, 50, 60)

s1 = {10, 20, 30}
s2 = {40, 50, 60}

s3 = s1 + s2
print(s3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[9], line 4
      1 s1 = {10, 20, 30}
      2 s2 = {40, 50, 60}
----> 4 s3 = s1 + s2
      5 print(s3)

TypeError: unsupported operand type(s) for +: 'set' and 'set'

s1 = {10, 20, 30}
s2 = {40, 50, 60}

s3 = {*s1, *s2}
print(s3)

{50, 20, 40, 10, 60, 30}

s1 = {10, 20, 30}
s2 = {40, 50, 60}
s = {"A", "B", "C"}

s3 = {*s1, *s2, *s}
print(s3)

{40, 10, 50, 'C', 20, 'A', 'B', 60, 30}

s1 = {10, 20, 30}
s2 = {40, 50, 60}
s = {"A", "B", "C"}

l = [*s1, *s2, *s]
print(l)

[10, 20, 30, 40, 50, 60, 'C', 'B', 'A']

s1 = {10, 20, 30}
s2 = (40, 50, 60)
s = ["A", "B", "C"]

list = [*s1, *s2, *s]
print(list)

[10, 20, 30, 40, 50, 60, 'A', 'B', 'C']

s1 = {10, 20, 30}
s2 = (40, 50, 60)
s = ["A", "B", "C"]

tuple = (*s1, *s2, *s)
print(tuple)

(10, 20, 30, 40, 50, 60, 'A', 'B', 'C')

s1 = {10, 20, 30}
s2 = (40, 50, 60)
s = ["A", "B", "C"]

set = {*s1, *s2, *s}
print(set)

{40, 10, 50, 'C', 20, 'A', 'B', 60, 30}

d1 = {100: "A", 200: "B"}
d2 = {300: "C", 400: "D"}
d3 = {500: "E", 600: "F"}

result = {}
print(result)

{}

result = {**d1, **d2, **d3}
print(result)

{100: 'A', 200: 'B', 300: 'C', 400: 'D', 500: 'E', 600: 'F'}

result = {*d1, *d2, *d3}
print(result)

{400, 100, 500, 200, 600, 300}

result = {*d1.values(), *d2.values(), *d3.values()}
print(result)

{'C', 'D', 'F', 'E', 'B', 'A'}

# # Limitations for + Operator :-

# 1. Applicable only for list, tuple but not for set and dict

# 2. Compulsory both arguments should be same type.

# # Nested Collections :-

# Collection inside Collection
# Django, DRF

# inside list, we can take tuple
# inside dict, we can take another dict

l = [(10, 20, 30), (40, 50, 60)]
print(l)

[(10, 20, 30), (40, 50, 60)]

print(l[0][1])

20

print(l[1][2])

60

d = {
    "cars": ("Innova", "Honda", "BMW"),
    "mobiles": ("Samsung", "Nokia", "Iphone"),
}

print(d["cars"])

('Innova', 'Honda', 'BMW')

print(d["cars"][1])

Honda

print(d.get("cars")[1])

Honda

# To display all mobile names
for mobile in d['mobiles']:
    print(mobile)

Samsung
Nokia
Iphone

# # Two Restrictions :-

    # Every element isnide set should be hashable.
    # Hence we cannot list object as element in set.

    # Every key inside dictionary should be hashable.
    # For the key we cannot take list object.

# Ques: Write a program to accept student name and marks from the keyboard and with that data creates a dictionary. Also display student marks by taking student name as input?

n = int(input("Enter Number of Students:"))
d = {}

while len(d) <= n:
    name = input("Enter Student Name:")
    marks = int(input("Enter Student Marks:"))
    d[name] = marks

print("All Students Data Inserted")
print(d)

while True:
    name = input("Enter Student Name to get Marks:")
    if name in d:
        print("The Marks of {}:{}".format(name, d.get(name)))
    else:
        print("Student Not Found")

    option = input("Do you want to find another Student Marks [Yes|No]:")
    while option.lower() not in ["yes", "no"]:
        option = input("Invalid Option, Please choose Valid Option [Yes|No]:")

    if option.lower() == "no":
        break

print('Thanks for Using Our Application')

All Students Data Inserted
{'ram': 85, 'shyam': 93, 'harry': 75, 'pavan': 72}
Student Not Found
Student Not Found
The Marks of ram:85
Thanks for Using Our Application

# Dictionary Comprehension :-

# List ---> Applicable
# Tuple ---> Not Applicable
# Set ---> Applicabel
# Dict ---> Applicable

l = [x * x for x in range(1, 6)]
print(l)

[1, 4, 9, 16, 25]

# key:value
# {1:1, 2:4, 3:9, 4:16, 5:25}

# d = {key:value for x in range(1,6)}

d = {x: x * x for x in range(1, 6)}
print(d)

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

d = {x: x * 2 for x in range(1, 6)}
print(d)

{1: 2, 2: 4, 3: 6, 4: 8, 5: 10}

d = {x: chr(64 + x) for x in range(1, 27)}
print(d)

{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E', 6: 'F', 7: 'G', 8: 'H', 9: 'I', 10: 'J', 11: 'K', 12: 'L', 13: 'M', 14: 'N', 15: 'O', 16: 'P', 17: 'Q', 18: 'R', 19: 'S', 20: 'T', 21: 'U', 22: 'V', 23: 'W', 24: 'X', 25: 'Y', 26: 'Z'}

# # Implementation of Supermarket Dictionary :-

# supermarket has multiple stores
# Every store has a name
# Every store has multiple items
# Every item has name and quantity

# key-value
# for key ---> hashable
# for value ---> we can take anything

supermarket = {
    "store1": {
        "name": "DURGA GENERAL STORE",
        "items": [
            {"name": "soap", "quantity": 20},
            {"name": "brush", "quantity": 30},
            {"name": "paste", "quantity": 40},
        ],
    },
    "store2": {
        "name": "SUNNY BOOK STORE",
        "items": [
            {"name": "Python", "quantity": 5},
            {"name": "Django", "quantity": 15},
            {"name": "Devops", "quantity": 25},
            {"name": "Django", "quantity": 65},
        ],
    },
}

print(supermarket)

{'store1': {'name': 'DURGA GENERAL STORE', 'items': [{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]}, 'store2': {'name': 'SUNNY BOOK STORE', 'items': [{'name': 'Python', 'quantity': 5}, {'name': 'Django', 'quantity': 15}, {'name': 'Devops', 'quantity': 25}, {'name': 'Django', 'quantity': 65}]}}

# To print name of store1

print(supermarket['store1'])

{'name': 'DURGA GENERAL STORE', 'items': [{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]}

print(supermarket['store1']['name'])

DURGA GENERAL STORE

print(supermarket.get('store1'))

{'name': 'DURGA GENERAL STORE', 'items': [{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]}

print(supermarket.get('store1').get('name'))

DURGA GENERAL STORE

# To print names of all items present in store1

print(supermarket['store1']['items'])

[{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]

print(supermarket.get('store1').get('items'))

[{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]

for d in supermarket['store1']['items']:
    print(d['name'])

soap
brush
paste

for d in supermarket.get('store1').get('items'):
    print(d.get('name'))

soap
brush
paste

for d in supermarket.get('store1').get('items'):
    print(d)

{'name': 'soap', 'quantity': 20}
{'name': 'brush', 'quantity': 30}
{'name': 'paste', 'quantity': 40}

# How many django books are available?

for d in supermarket["store2"]["items"]:
    if d["name"] == "Django":
        print("The Number of Django Books:", d["quantity"])

The Number of Django Books: 15
The Number of Django Books: 65

# Ques: Which of the following allowed in Python?

# 1. List inside List
# 2. Tuple inside List
# 3. List inside Tuple
# 4. Tuple inside Set
# 5. List inside Set    ---> Invalid
# 6. Set inside Set     ---> Invalid
# 7. List as key in Dict   ---> Invalid
# 8. List as Value in Dict
# 9. Tuple as key in Dict
# 10. Tuple as Value in Dict
# 11. Set as key in Dict    ---> Invalid
# 12. Set as Value in Dict

s = {10,20,[30,40]}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[52], line 1
----> 1 s = {10,20,[30,40]}

TypeError: unhashable type: 'list'

s = {10,20,{30,40}}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[53], line 1
----> 1 s = {10,20,{30,40}}

TypeError: unhashable type: 'set'

# # Note :-

    # List, Set are not hashable types.
    # Every element inside set should be hashable. Hence we cannot take list, ste inside set.

    # Key of Dict should be hashable.
    # Hence we cannot take list, set as inside dict.

# List is unhashable, but how list inside list is accepted

    # In List and tuple, elements will be inserted based on order and index and PVM won't required any hash. Hence elements need not be hashable.

    # But in set and dict, elements will be inserted based on hash. Hence elements should be hashable.

d = {[10, 20]: "ram"}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[60], line 1
----> 1 d = {[10, 20]: "ram"}

TypeError: unhashable type: 'list'

d = {(10, 20): "ram"}

d = {{10, 20}: "ram"}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[62], line 1
----> 1 d = {{10, 20}: "ram"}

TypeError: unhashable type: 'set'

# # Functions :-

# DRY -- Principle
# Don't Repeat Yourself

# code reusability

def calc(a, b):
    print("Sum:", a + b)
    print("Product:", a * b)
    print("Difference:", a - b)
    print("Dividend:", a / b)


calc(10, 20)
calc(20, 30)

Sum: 30
Product: 200
Difference: -10
Dividend: 0.5
Sum: 50
Product: 600
Difference: -10
Dividend: 0.6666666666666666

# # Types of Functions :-

    # 1. Built in Functions

    # 2. User Defined Functions

# 1. Built in Functions :-

# predefined functions

# id()
# print()
# input()
# eval()
# len()

# 2. User Defined Functions :-

# syntax for user defined function :

    # def function_name(parameters):
        # ''' doc string '''
        # business logic
        # business logic
        # business logic
        # business logic
        # return value

# def ---> mandatory
# return ---> optional

# def m2(a,b):
    # some Code

# class Test:
    # def m1(self):
        # some code

# Functions inside class ---> Methods

# Ques: Write a function to print hello?

def wish():  # Defining a function
    print("hello")


wish()  # Calling a function

hello

wish()
print("hi")
wish()
print("hi")
wish()
print("hi")
wish()

hello
hi
hello
hi
hello
hi
hello

# Parameters :-

# Parameters are inputs to the function.
# If a function takes parameters, at the time of calling function, values.

def wish(name):
    print("Hello {}, Good Morning!".format(name))


wish("Harry")

Hello Harry, Good Morning!

name = input("Enter Name:")
wish(name)

Hello Harry, Good Morning!

# Ques: WAP to take number as arguments and print its square value?

def squareIt(number):
    print("The square of {} is : {}".format(number, number**2))


squareIt(4)
squareIt(5)
squareIt(6)
squareIt(7)

The square of 4 is : 16
The square of 5 is : 25
The square of 6 is : 36
The square of 7 is : 49

def add(x, y):
    print("The Sum of {} and {} is : {}".format(x, y, x + y))


add(10, 20)
add(20, 30)
add(30, 40)
add(40, 50)

The Sum of 10 and 20 is : 30
The Sum of 20 and 30 is : 50
The Sum of 30 and 40 is : 70
The Sum of 40 and 50 is : 90

# Return Statements :-

# Ques: WAF to accept 2 numbers as input and return sum?

def add(x, y):
    return x + y


result = add(10, 20)
print("Sum:", result)

Sum: 30

def add(x, y):
    print('Calling add function...')
    return x + y


add(10, 20)

Calling add function...

30

def validate(mobile_number):
    if len(mobile_number) == 10:
        return True
    else:
        return False


mobile_number = input("Enter Mobile Number:")
result = validate(mobile_number)
print(result)

True

def f1():
    print('Hello')

result = f1()
print(result)

Hello
None

# Every Function in Python in return some value.

# If you are not returning any value then by default return value is None.

x = 10
print(id(x))

140709881824328

print(print(x))

10
None

# Ques: WAF to check whether the given number is even or odd?

def even_odd(x):
    if x % 2 == 0:
        print("It is even number")
    else:
        print("It is odd number")


even_odd(15)
even_odd(10)

It is odd number
It is even number

even_odd(int(input('Enter Some Number to Check:')))

It is even number

def even_odd():
    x = int(input("Enter some Number:"))
    if x % 2 == 0:
        print("It is even number")
    else:
        print("It is odd number")


even_odd()

It is odd number

def even_odd(x):
    if x % 2 == 0:
        return "It is even number"
    else:
        return "It is odd number"

result = even_odd(15)
print(result)

It is odd number

def show(sequence):
    for x in sequence:
        print(x)


show("durga")
show(range(1, 6))

d
u
r
g
a
1
2
3
4
5

# Ques: WAF to find Factorial of given number?

def factorial(x):
    result = 1
    while x >= 1:
        result = result * x
        x = x - 1
    return result


for i in range(0, 11):
    print("The Factorial of {} is : {}".format(i, factorial(i)))

The Factorial of 0 is : 1
The Factorial of 1 is : 1
The Factorial of 2 is : 2
The Factorial of 3 is : 6
The Factorial of 4 is : 24
The Factorial of 5 is : 120
The Factorial of 6 is : 720
The Factorial of 7 is : 5040
The Factorial of 8 is : 40320
The Factorial of 9 is : 362880
The Factorial of 10 is : 3628800

def factorial(x):
    result = 1
    while x >= 1:
        result = result * x
        x = x - 1
    print("The Factorial of {} is : {}".format(x, result))


for i in range(0, 11):
    factorial(i)

The Factorial of 0 is : 1
The Factorial of 0 is : 1
The Factorial of 0 is : 2
The Factorial of 0 is : 6
The Factorial of 0 is : 24
The Factorial of 0 is : 120
The Factorial of 0 is : 720
The Factorial of 0 is : 5040
The Factorial of 0 is : 40320
The Factorial of 0 is : 362880
The Factorial of 0 is : 3628800

def calc(a, b):
    sum = a + b
    sub = a - b
    return sum, sub


x, y = calc(20, 10)
print(x, y)
print("Sum:", x)
print("Difference:", y)

30 10
Sum: 30
Difference: 10

x = calc(20, 10)
print(x)

(30, 10)

def calc(a, b):
    sum = a + b
    sub = a - b
    return [sum, sub]


x, y = calc(20, 10)
print(x, y)
print("Sum:", x)
print("Difference:", y)

x = calc(20, 10)
print(x)

30 10
Sum: 30
Difference: 10
[30, 10]

# Types of Arguments/Parameters :-

def f1(a, b):  # Formal Parameters
    pass


f1(10, 20)  # Arguments

# 4 Types of Parameters/Arguments :-
    # 1. Positional Arguments

    # 2. Keyword Arguments

    # 3. Default Arguments

    # 4. Varable Length Arguments

# 1. Positional Arguments :-

def sub(a, b):
    print(a - b)

sub(10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[7], line 1
----> 1 sub(10)

TypeError: sub() missing 1 required positional argument: 'b'

sub(10, 20)
sub(20, 10)
# The number of arguments must be matched
# The order of arguments is important, The result may be changed if we change order

-10
10

sub(10, 20, 30)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[12], line 1
----> 1 sub(10, 20, 30)

TypeError: sub() takes 2 positional arguments but 3 were given

# 2. Keyword Arguments :-

# We have to pass argument values by keyword i.e by paramter name.

# The number of arguments must be matched.

# The order is not important.

def sub(a, b):
    print(a - b)


sub(a=10, b=20)

-10

sub(a=10, b=20)

sub(b=20, a=10)

-10
-10

# # Note :-

    # We can use both positional arguments and keyword arguments simultaneously, but first positional arguments then keyword arguments.

    # But keyword arguments won't follow positional arguments.

    # Key name should be case sensitive.

def sub(a, b):
    print(a - b)

sub(a=10, b=20)

-10

sub(x=10, b=20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[28], line 1
----> 1 sub(x=10, b=20)

TypeError: sub() got an unexpected keyword argument 'x'

sub(10, b=20)

-10

sub(10, a=20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[32], line 1
----> 1 sub(10, a=20)

TypeError: sub() got multiple values for argument 'a'

sub(a=10, 20)

  Cell In[33], line 1
    sub(a=10, 20)
                ^
SyntaxError: positional argument follows keyword argument

sub(b=10, 20)

  Cell In[34], line 1
    sub(b=10, 20)
                ^
SyntaxError: positional argument follows keyword argument

def sub(a, b, c, d, e):
    print(a - b)


sub(10, 20, 30, 40, e=10)

-10

sub(10, 20, 30, 40, d=10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[37], line 1
----> 1 sub(10, 20, 30, 40, d=10)

TypeError: sub() got multiple values for argument 'd'

sub(10, 20, c=30, d=40, e=10)

-10

sub(10, 20, d=40, e=10, c=30)

-10

def wish(name, msg):
    print("Hello", name, msg)

wish("Durga", "Good Morning")

Hello Durga Good Morning

wish("Durga", msg="Good Morning")

Hello Durga Good Morning

wish(name ="Durga", "Good Morning")

  Cell In[45], line 1
    wish(name ="Durga", "Good Morning")
                                      ^
SyntaxError: positional argument follows keyword argument

wish(name="Durga", msg="Good Morning")

Hello Durga Good Morning

# 3. Default Arguments :-

def wish(name="Guest"):
    print("Hello", name, "Good Morning")

wish()

Hello Guest Good Morning

wish('Durga')

Hello Durga Good Morning

# Positional arguments and keywords arguments we have to take at the time of calling.

# But default arguments at the time of declaration.

wish(name ='Durga')

Hello Durga Good Morning

def wish(name="Guest", msg="Good Morning"):
    print("Hello", name, msg)

wish()

Hello Guest Good Morning

wish(name="Durga")

Hello Durga Good Morning

wish("Durga", msg="Good Evening")

Hello Durga Good Evening

wish("Good Evening")

Hello Good Evening Good Morning

wish(name="Durga", msg="Good Evening")

Hello Durga Good Evening

wish(msg="Good Evening")

Hello Guest Good Evening

wish(name="Durga", "Good Evening")

  Cell In[63], line 1
    wish(name="Durga", "Good Evening")
                                     ^
SyntaxError: positional argument follows keyword argument

def wish(name="Guest", msg="Good Morning"):
    pass

def wish(name, msg="Good Morning"):
    pass

def wish(name="Guest", msg):
    pass

  Cell In[66], line 1
    def wish(name="Guest", msg):
                           ^
SyntaxError: non-default argument follows default argument

# Default arguments should be last arguments. i.e after default arguments we cannot take non-default arguments.

def wish(msg, name="Guest"):
    pass

# 4. Variable Length Arguments :-

# Varaible number of arguments: at the time of declaration/definition.

def f(*x):
    print("The Type of x:", type(x))
    print("The Number of arguments passed:", len(x))

f()

The Type of x: <class 'tuple'>
The Number of arguments passed: 0

f(10)

The Type of x: <class 'tuple'>
The Number of arguments passed: 1

f(10, 20)

The Type of x: <class 'tuple'>
The Number of arguments passed: 2

f(10, 20, 30)

The Type of x: <class 'tuple'>
The Number of arguments passed: 3

f(10, 20, 30, 40)

The Type of x: <class 'tuple'>
The Number of arguments passed: 4

f(10, 20, 30, 40, 50, 60, 70, 80, 90)

The Type of x: <class 'tuple'>
The Number of arguments passed: 9

def sum(*n):
    total = 0
    for n1 in n:
        total = total + n1
    print("Sum:", total)

sum(10)

Sum: 10

sum(10, 20)

Sum: 30

sum(10, 20, 30, 40, 50, 60)

Sum: 210

sum()

Sum: 0

def sum(*n):
    for n1 in n:
        print(n1)

sum(10, "durga")

10
durga

def sum(*n):
    print(n)


sum(10, "durga")

(10, 'durga')

# We can use normal arguments and varaible length arguments simultaneously.

# We can take variable length argument anywhere.

def sum(n, *s):
    print(n)
    print(s)

sum(10, 20, 30, 40, 50)

10
(20, 30, 40, 50)

def sum(*s, n):
    print(s)
    print(n)

sum(10, 20, 30, 40, 50)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[104], line 1
----> 1 sum(10, 20, 30, 40, 50)

TypeError: sum() missing 1 required keyword-only argument: 'n'

sum(10, 20, 30, 40, 50, n=10)

(10, 20, 30, 40, 50)
10

# After variable lengtrh argument, if we are taking normal argument, we should provide value by using keyword only.

sum(10, 20, 30, 40, n=10, 50)

  Cell In[111], line 1
    sum(10, 20, 30, 40, n=10, 50)
                                ^
SyntaxError: positional argument follows keyword argument

def sum(*s, n=0):
    print(s)
    print(n)

sum(10, 20, 30, 40, 50)

(10, 20, 30, 40, 50)
0

sum(10, 20, 30, 40, 50, n=60)

(10, 20, 30, 40, 50)
60

def sum(n=0, *s):
    print(s)
    print(n)

sum(10, 20, 30, 40, 50, n=60)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[118], line 1
----> 1 sum(10, 20, 30, 40, 50, n=60)

TypeError: sum() got multiple values for argument 'n'

sum(n=60, 10, 20, 30, 40, 50)

  Cell In[119], line 1
    sum(n=60, 10, 20, 30, 40, 50)
                                ^
SyntaxError: positional argument follows keyword argument

sum(10, 20, 30, 40, 50)

(20, 30, 40, 50)
10

# After default arguments, we cannot take noraml arguments but we can take variable length arguments.

def sum(*m, *n):
    print(m)
    print(n)

  Cell In[122], line 1
    def sum(*m, *n):
                ^
SyntaxError: * argument may appear only once

# We cannot take more than one variable keyword argument.

def sum(*a, b, c, d, e):
    pass

sum(1, 2, 3, 4, 5)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[125], line 1
----> 1 sum(1, 2, 3, 4, 5)

TypeError: sum() missing 4 required keyword-only arguments: 'b', 'c', 'd', and 'e'

# 1. Positional Arguments
# 2. Keyword Arguments
# 3. Default Arguments
# 4. Variable Length Argumnets

# 1. Positional Arguments :-

    # At the time of calling

    # Order and Number are Important

def f1(a, b):
    print(a - b)


f1(10, 20)

-10

# 2. Keyword Arguments :-

    # At the time of calling

    # Order/Position is not Important

def f1(a, b):
    print(a - b)


f1(a=10, b=20)

-10

# We can use positional and keyword argumnets together but :

# First we should use positional argumnets and then keyword arguments.

# 3. Default Arguments :-

    # At the time of declaration/creation.

    # After taking default arguments, we cannot take normal arguments. But we can take variable length arguments.

def f1(a, b=0):
    print(a - b)


f1(a=10)
f1(a=10, b=20)

10
-10

def f1(a=0, b):
    print(a - b)


f1(a=10)
f1(a=10, b=20)

  Cell In[12], line 1
    def f1(a=0, b):
                ^
SyntaxError: non-default argument follows default argument

def f1(a=0, *b):
    print(a - b)


f1(a=10)
f1(a=10, b=20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[13], line 5
      1 def f1(a=0, *b):
      2     print(a - b)
----> 5 f1(a=10)
      6 f1(a=10, b=20)

Cell In[13], line 2, in f1(a, *b)
      1 def f1(a=0, *b):
----> 2     print(a - b)

TypeError: unsupported operand type(s) for -: 'int' and 'tuple'

# 4. Variable Length Arguments :-

    # At the time of declaration/creation

    # We can take variable length arguments anywhere.

    # But after variable length argument, if we are taking any normal argument, compulsory we should pass value by keyword.

    # We can take only one variable-length argument.

def f1(*x):
    print(x)


f1(10, 20, 30, 40)

(10, 20, 30, 40)

def f1(*x, y):
    print(x)
    print(y)

f1(10, 20, 30, 40)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[19], line 1
----> 1 f1(10, 20, 30, 40)

TypeError: f1() missing 1 required keyword-only argument: 'y'

f1(10, 20, 30, y=40)

(10, 20, 30)
40

def fn(*var1, var2):
    print(var1)
    print(var2)


fn(10, "durga", 10.5, True, var2=40)

(10, 'durga', 10.5, True)
40

# *x ---> We can provide any number of values for x and x will become tuple.
# *args

# **x ---> We can pass any number of key-value pairs and x will become dict.
# **kwargs

def display(**kwargs):
    print(type(kwargs))
    print(kwargs)

display(10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[25], line 1
----> 1 display(10)

TypeError: display() takes 0 positional arguments but 1 was given

display(name="Durga", rollno=101, narks=90)

<class 'dict'>
{'name': 'Durga', 'rollno': 101, 'narks': 90}

def display(**kwargs):
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(name="Durga", rollno=101, narks=90)

name=Durga
rollno=101
narks=90

# .items ---> provide list of items

def display(**kwargs):
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(name="Durga", rollno=101, narks=90)

dict_items([('name', 'Durga'), ('rollno', 101), ('narks', 90)])
name=Durga
rollno=101
narks=90

def display(*args, **kwargs):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90)

(10, 20, 30)
dict_items([('name', 'Durga'), ('rollno', 101), ('narks', 90)])
name=Durga
rollno=101
narks=90

def display(*args, **kwargs, x):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90)

  Cell In[35], line 1
    def display(*args, **kwargs, x):
                                 ^
SyntaxError: arguments cannot follow var-keyword argument

def display(*args, **kwargs, x=10):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90)

  Cell In[37], line 1
    def display(*args, **kwargs, x=10):
                                 ^
SyntaxError: arguments cannot follow var-keyword argument

# After varible length argument after **kwargs, it won't except any other type of argument.

def display(*args, **kwargs, x=10):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90, x=10)

  Cell In[43], line 1
    def display(*args, **kwargs, x=10):
                                 ^
SyntaxError: arguments cannot follow var-keyword argument

# Rules to Remember :-

# 1. After keyword arguments, we cannot take positional arguments.

# 2. After default arguments, we cannit take normal arguments, but we can take variable length arguments.

# 3. After Variable length arguments, if we are taking any normal argument, compulsory we should provide values by keyword only.

# 4. We can take atmost one varaible length argument.

# 5. **kwargs should be last arguments.

def f1(arg1, arg2, arg3=4, arg4=8):
    print(arg1, arg2, arg3, arg4)

f1(3, 2)

3 2 4 8

f1(10, 20, 30, 40)

10 20 30 40

f1(25, 50, arg4=100)

25 50 4 100

f1(arg4=2, arg1=3, arg2=4)

3 4 4 2

f1()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[50], line 1
----> 1 f1()

TypeError: f1() missing 2 required positional arguments: 'arg1' and 'arg2'

f1(arg3=10, arg4=20, 30, 40)

  Cell In[52], line 1
    f1(arg3=10, arg4=20, 30, 40)
                               ^
SyntaxError: positional argument follows keyword argument

f1(4, 5, arg2=6)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[53], line 1
----> 1 f1(4, 5, arg2=6)

TypeError: f1() got multiple values for argument 'arg2'

f1(4, 5, arg3=5, arg5=6)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[54], line 1
----> 1 f1(4, 5, arg3=5, arg5=6)

TypeError: f1() got an unexpected keyword argument 'arg5'

def f1(*x, y=20):
    print(x)
    print(y)

f1(10, 20, 30, 777)

(10, 20, 30, 40)
20

f1(10, 20, 30, y=777)

(10, 20, 30)
777

# # Types of Variables/Variable Scopes :-

# 1. Global Variables
# 2. Local Variables

# 1. Global Variables :-

# The variables which are declared outside of the function
# Avaialable for all functions.

a = 10


def f1():
    print(a)


def f2():
    print(a)


f1()
f2()

10
10

# 2. Local Variables :-

# The variables which are declared inside of the function
# Avaialable only for that function.

def f1():
    b = 10
    print(b)


f1()

10

def f1():
    b = 10
    print(b)


def f2():
    print(b)


f1()
f2()

10

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[12], line 11
      7     print(b)
     10 f1()
---> 11 f2()

Cell In[12], line 7, in f2()
      6 def f2():
----> 7     print(b)

NameError: name 'b' is not defined

# Gloabl ===> Global to all functions.
# Local ===> Local to a particular function.

a = 10  # Global variable


def f1():
    a = 777  # Local variable
    print(a)


def f2():
    print(a)


f1()
f2()

777
10

# Global Keyword :-

# 1. To make global varaibles available to the functions so that we can perform required modifications.

a = 10  # Global variable


def f1():
    global a  # Make Global variable available to f1
    a = 777
    print(a)


def f2():
    print(a)


f1()
f2()

777
777

a = 10  # Global variable


def f1():
    global a = 777    # Make Global variable available to f1
    print(a)


def f2():
    print(a)


f1()
f2()

  Cell In[19], line 5
    global a = 777    # Make Global variable available to f1
             ^
SyntaxError: invalid syntax

# 2. To declare global variables inside functions.

def f1():
    global c  # Now onwards c is global varibale but not local variable
    c = 10
    print(c)


def f2():
    print(c)


f1()
f2()

10
10

def f1():
    global d  # Now onwards d is global varibale but not local variable
    d = 10
    print(d)


def f2():
    print(d)


f2()

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[16], line 11
      7 def f2():
      8     print(d)
---> 11 f2()

Cell In[16], line 8, in f2()
      7 def f2():
----> 8     print(d)

NameError: name 'd' is not defined

def f1():
    global e  # Now onwards e is global varibale but not local variable
    e = 10
    print(e)


def f2():
    e = 777
    print(e)


f1()
f2()
print(e)

10
777
10

f = 10


def f1():
    f = 777
    print(f)


f1()
print(f)

777
10

# How to print global varibale value inside fuction containing local variable.

# If the local and global varibale have the same name then how to differentiate values?

a1 = 10


def f1():
    a1 = 777
    print("Local Variable Value:", a1)

    # How to print global variable value of 'a1'
    global a1
    print("Global Variable Value:", a1)


f1()

  Cell In[30], line 9
    global a1
    ^
SyntaxError: name 'a1' is used prior to global declaration

a1 = 10


def f1():
    a1 = 777
    print("Local Variable Value:", a1)

    # How to print global variable value of 'a1'
    print("Global Variable Value:", globals())


f1()

Local Variable Value: 777
Global Variable Value: {'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', 'a = 10\n\n\ndef f1():\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a\n    a = 777     # Local variable\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# # Global Keyword :-', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '# 2. ', '# 2. To declare global variables inside functions.', 'def f1():\n    global c    # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global d  # Now onwards c is global varibale but not local variable\n    d = 10\n    print(d)\n\n\ndef f2():\n    print(d)\n\n\nf2()', 'def f1():\n    global e  # Now onwards e is global varibale but not local variable\n    e = 10\n    print(e)\n\n\ndef f2():\n    e = 777\n    print(e)\n\nf1()\nf2()\nprint(e)', 'a = 10  # Global variable\n\n\ndef f1():\n    global a  # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '# How to print global varibale value inside fuction containing local variable', '# How to print global varibale value inside fuction containing local variable.\n\n# If the local and global varibale have the same name then how to differentiate values?', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals(a1))\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()'], '_oh': {}, '_dh': [WindowsPath('c:/Users/pulki/Python/python_fundamentals')], 'In': ['', 'a = 10\n\n\ndef f1():\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a\n    a = 777     # Local variable\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# # Global Keyword :-', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '# 2. ', '# 2. To declare global variables inside functions.', 'def f1():\n    global c    # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global d  # Now onwards c is global varibale but not local variable\n    d = 10\n    print(d)\n\n\ndef f2():\n    print(d)\n\n\nf2()', 'def f1():\n    global e  # Now onwards e is global varibale but not local variable\n    e = 10\n    print(e)\n\n\ndef f2():\n    e = 777\n    print(e)\n\nf1()\nf2()\nprint(e)', 'a = 10  # Global variable\n\n\ndef f1():\n    global a  # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '# How to print global varibale value inside fuction containing local variable', '# How to print global varibale value inside fuction containing local variable.\n\n# If the local and global varibale have the same name then how to differentiate values?', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals(a1))\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()'], 'Out': {}, 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0000021A49C68B50>>, 'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000021A49C75990>, 'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000021A49C75990>, 'open': <function open at 0x0000021A47C06AC0>, '_': '', '__': '', '___': '', '__vsc_ipynb_file__': 'c:\\Users\\pulki\\Python\\python_fundamentals\\58_Types_of_Variables.ipynb', '_i': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', '_ii': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', '_iii': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', '_i1': 'a = 10\n\n\ndef f1():\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a': 777, 'f1': <function f1 at 0x0000021A49D6A2A0>, 'f2': <function f2 at 0x0000021A4A29D620>, '_i2': 'a = 10  # Global variable\n\n\ndef f1():\n    global a\n    a = 777     # Local variable\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i3': 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i4': '# # Global Keyword :-', '_i5': 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i6': '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '_i7': 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i8': 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i9': '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '_i10': '# 2. ', '_i11': '# 2. To declare global variables inside functions.', '_i12': 'def f1():\n    global c    # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'c': 10, '_i13': 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', '_i14': 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', '_i15': 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', '_i16': 'def f1():\n    global d  # Now onwards c is global varibale but not local variable\n    d = 10\n    print(d)\n\n\ndef f2():\n    print(d)\n\n\nf2()', '_i17': 'def f1():\n    global e  # Now onwards e is global varibale but not local variable\n    e = 10\n    print(e)\n\n\ndef f2():\n    e = 777\n    print(e)\n\nf1()\nf2()\nprint(e)', 'e': 10, '_i18': 'a = 10  # Global variable\n\n\ndef f1():\n    global a  # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i19': 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i20': 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()', 'f': 10, '_i21': 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '_i22': 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '_i23': '# How to print global varibale value inside fuction containing local variable', '_i24': '# How to print global varibale value inside fuction containing local variable.\n\n# If the local and global varibale have the same name then how to differentiate values?', '_i25': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()\nprint(f)', 'a1': 10, '_i26': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals(a1))\n\n\nf1()\nprint(f)', '_i27': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()\nprint(f)', '_i28': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', '_i29': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', '_i30': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', '_i31': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()'}

a1 = 10


def f1():
    a1 = 777
    print("Local Variable Value:", a1)

    # How to print global variable value of 'a1'
    print("Global Variable Value:", globals()['a1'])
    print("Global Variable Value:", globals().get('a1'))


f1()

Local Variable Value: 777
Global Variable Value: 10
Global Variable Value: 10

a = 10
for i in range(1):
    b = 20

print(a, b)

10 20

# # Recursive Functions :-

# A function that calls itself is known as Recursive Function.

# factorial(n) = n * (n-1) * (n-2) * ....1
# factorial(n) = n * factorial(n-1)

# 1. We can reduce the length of the code and improves readability.

# 2. We can solve very complex problems also very easily.

def factorial(n):
    print("Finding Factorial of", n)
    if n == 0:
        result = 1
    else:
        result = n * factorial(n - 1)

    print("Completion of Finding Factorial of {} and Result is {}".format(n, result))
    return result


print("Factorial :", factorial(4))

Finding Factorial of 4
Finding Factorial of 3
Finding Factorial of 2
Finding Factorial of 1
Finding Factorial of 0
Completion of Finding Factorial of 0 and Result is 1
Completion of Finding Factorial of 1 and Result is 1
Completion of Finding Factorial of 2 and Result is 2
Completion of Finding Factorial of 3 and Result is 6
Completion of Finding Factorial of 4 and Result is 24
Factorial : 24

def fib(n):
    if n == 0:
        return 0
    elif n == 1 or n == 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)


print(fib(4))

3

print(fib(5))

5

print(fib(6))

8

# # Anonymous Fuctions/ Lambda Functions :-

# Nameless functions are called anonymous functions.

# # Normal Function :-

    # By using def keyword
    # function name: squareIt

def squareIt(n):
    return n * n

# Anonymous Function :-

# We have to use lambda keyword

# lambda n : n * n
# lambda arguments_list:expression

s = lambda n: n * n
print("The Square is {}".format(s(4)))

The Square is 16

# Lambda Function to find sum of 2 given numbers?

s = lambda a, b: a + b
print("Sum:", s(10, 20))

Sum: 30

# To find biggest of 2 numbers?

s = lambda a, b: a if a > b else b
print("Biggest Number is", s(10, 20))

Biggest Number is 20

# To find biggest of 3 numbers?

s = lambda a, b, c: a if a > b and a > c else b if b > c else c
print("Biggest Number is", s(10, 20, 30))

Biggest Number is 30

# # Python Lambda functions are always single line functions only.

# # Lmabda Functions :-

# We can pass a function as argument to another functions.
# In such cases Lambda functions are best choice.

# filter()
# map()
# reduce()

# 1. filter() Function :-

# To filter values based on some condition.

# 10 values filter top 3 values.

# 10 numbers filter only even numbers.

# input = [1, 2, 3, 4, 5, 6, 7, 8]

# [2, 4, 6, 8]

# filter(function, sequence)

def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False


l = [0, 5, 10, 15, 20, 25]
output = filter(is_even, l)
print(type(output))
print(output)

<class 'filter'>
<filter object at 0x0000026C05F20DF0>

l = [0, 5, 10, 15, 20, 25]
output = list(filter(is_even, l))
print(type(output))
print(output)

<class 'list'>
[0, 10, 20]

def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False


l = [0, 5, 10, 15, 20, 25]
output = []
for x in l:
    if is_even(x) == True:
        output.append(x)

print(type(output))
print(output)

<class 'list'>
[0, 10, 20]

# It means filter internally looping for each value present in list.

def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False


lambda n: n % 2 == 0

<function __main__.<lambda>(n)>

l = [0, 5, 10, 15, 20, 25]
evens = list(filter(lambda n: n % 2 == 0, l))
odds = list(filter(lambda n: n % 2 != 0, l))

print(evens)
print(odds)

[0, 10, 20]
[5, 15, 25]

t = ("A", "AA", "AAA", "AAAA", "AAAAA")
# return all strings where length is >= 3

output = list(filter(lambda s: len(s) >= 3, t))
print(output)

['AAA', 'AAAA', 'AAAAA']

# List of employee objects. List out all employees which can go to pub?
#  his salary is > 10000 and he has gf and his age > 21

# l = [e1, e2, e3, e4]
# output = filter(lambda e:e.sal > 10000 and e.age > 21 and e.hasgf == True, l)

# 2. map() Function :-

# filter()
    # input : 10 elements
    #  output : 10 or less

# map()
    # input : 10 elements
    # output : 10 elements

# For every input value, generate output value based on some operation increment 10% salary for every employee.

# map(function, sequence)

def squarIt(n):
    return n * n


l = [1, 2, 3, 4, 5]
m = map(squarIt, l)
print(type(m))
print(m)

<class 'map'>
<map object at 0x00000216D4BB6530>

l = [1, 2, 3, 4, 5]
m = list(map(squarIt, l))
print(type(m))
print(m)

<class 'list'>
[1, 4, 9, 16, 25]

# # without lambda function :-

def squarIt(n):
    return n * n


l = [1, 2, 3, 4, 5]
m = list(map(squarIt, l))
print(type(m))
print(m)

# # with lambda function :-

l = [1, 2, 3, 4, 5]
m = list(map(lambda n: n * n, l))
print(type(m))
print(m)

<class 'list'>
[1, 4, 9, 16, 25]
<class 'list'>
[1, 4, 9, 16, 25]

l = [1, 2, 3, 4, 5]
m = list(map(lambda n: 2 * n, l))
print(m)

[2, 4, 6, 8, 10]

l = [0, 5, 10, 15, 20, 25]

# list out all odd numberws from the list

output = list(filter(lambda n: n % 2 != 0, l))
print(output)

[5, 15, 25]

# list out all numbers which are divisible by 3

output = list(filter(lambda n: n % 3 == 0, l))
print(output)

[0, 15]

# list = [0, 5, 10, 15, 20, 25]

# # list out all odd numberws from the list

# output = list(filter(lambda n: n % 2 != 0, list))
# print(output)

# # TypeError                                 Traceback (most recent call last)
# # Cell In[3], line 5
# #       1 list = [0, 5, 10, 15, 20, 25]
# #       3 # list out all odd numberws from the list
# # ----> 5 output = list(filter(lambda n: n % 2 != 0, list))
# #       6 print(output)

# # TypeError: 'list' object is not callable

list1 = [0, 5, 10, 15, 20, 25]

# list out all odd numberws from the list

output = list(filter(lambda n: n % 2 != 0, list1))
print(output)

[5, 15, 25]

# create a new list with double of values present in list1

output = list(map(lambda n: 2 * n, list1))
print(output)

[0, 10, 20, 30, 40, 50]

# create a new list with numbers which are divisible by 3

output = list(map(lambda n: n % 3 == 0, list1))
print(output)

[True, False, False, True, False, False]

# input : 10 values

# output :
#     filter()    ---> 10 or less
#     map()       ---> 10

# map(function, list)

# We can use map function on multiple list also

l1 = [1, 2, 3, 4]
l2 = [10, 20, 30, 40]

# Generate output by multiplying values from both lists

output = list(map(lambda x, y: x * y, l1, l2))
print(output)

[10, 40, 90, 160]

l1 = [1, 2, 3, 4, 5]
l2 = [10, 20, 30, 40, 50, 60, 70]

# Generate output by multiplying values from both lists

output = list(map(lambda x, y: x * y, l1, l2))
print(output)

[10, 40, 90, 160, 250]

# 3. reduce() Function :-

# reduce(function, sequence)

# input : 10 values

# output :
#     filter()    ---> 10 or less
#     map()       ---> 10
#     reduce()    ---> 1

l = [10, 20, 30, 40, 50]

result = reduce(lambda x, y: x + y, l)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[18], line 3
      1 l = [10, 20, 30, 40, 50]
----> 3 result = reduce(lambda x,y:x+y,)

NameError: name 'reduce' is not defined

from functools import *

l = [10, 20, 30, 40, 50]

result = reduce(lambda x, y: x + y, l)
print(result)

150

# print the sum of numbers from 1 to 100

result = reduce(lambda x, y: x + y, range(1, 101))
print(result)

5050

result = reduce(lambda x, y: x * y, range(1, 4))
print(result)

6

def multiply(x, y):
    return x * y


result = reduce(multiply, range(1, 4))
print(result)

6

# In the above example we have not pass the parameter to multiply then how it is working?

# We are not calling multiple fucntion. reduce() function is calling internally.

# # Modules :-

# A group of functions, variables and classes saved to a file, which is nothing but module.

# Every Python file (.py file) is a module.

# Advantages of Module :-
    # 1. Code Reusability

    # 2. Readability

    # 3. Maintainability

    # 4. Development Time

    # 5. Cost of Project

x = 888
name = "DURGASOFT"


def add(a, b):
    print("SUM : ", a + b)


def product(a, b):
    print("PRODUCT : ", a * b)


# Save by file name durgamath.py

# import modulename
# modulename.varaiblename
# modulename.functionname()

import durgamath
print(durgamath.x)
print(durgamath.name)

888
DURGASOFT

durgamath.add(10, 20)

SUM :  30

durgamath.product(10, 20)

PRODUCT :  200

# .pyc file will be generated for modules in __pycache__ which we wrote when we call them or when we use.

# .pyc file will be not generated for normal .py file unless we use it as a module.

# Module Name Aliasing :-

import durgamath as dm

print(dm.x)
print(dm.name)
dm.add(10, 20)
dm.product(10, 20)

888
DURGASOFT
SUM :  30
PRODUCT :  200

# Once we define alias name, we cannot use original name.

# from import :-

# Usually we can acces members of a module by using module name.

# If we don't want to use module name then we should go for from import.

# We can access members directly.

from durgamath import x, name

print(x)
print(name)

888
DURGASOFT

add(10,20)

SUM :  30

from durgamath import *     # to import everything from file

print(dm.x)
print(dm.name)
dm.add(10, 20)
dm.product(10, 20)

888
DURGASOFT
SUM :  30
PRODUCT :  200

# We can write import statement anywhere in the code it is not compulsory to add import as 1st statement.

# Member Aliasing :-

from durgamath import add as a, product as b, name as n

print(n)
a(10, 20)
b(10, 20)

DURGASOFT
SUM :  30
PRODUCT :  200

a(10, 20, 30)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[21], line 1
----> 1 a(10, 20, 30)

TypeError: add() takes 2 positional arguments but 3 were given

# from durgamath as dm import add as a, product as p

# is this right?

# No, it is not correct.

# Various Possibilities of import :-

# import module1
# import module1, module2, module3
# import module1 as m1
# import module1 as m1, module2 as m2, module3 as m3
# from module1 import member1
# from module1 import member1, member2, member3
# from module import *
# from module import member1 as m1
# from module import member1 as m1, member2 as m2

# from module1, module2 import *    ===> Invalid

# Module Naming Conflicts :-

from module1 import *

add(10, 20)

module1 add function
SUM: 30

from module2 import *

add(10, 20)

module2 add function
SUM: 30

from module1 import *
from module2 import *

add(10, 20)

module2 add function
SUM: 30

from module1 import *
from module2 import *


def add(a, b):
    print("Current Module Add Function")
    print("SUM:", a + b)


add(10, 20)

Current Module Add Function
SUM: 30

from module1 import *


def add(a, b):
    print("Current Module Add Function")
    print("SUM:", a + b)


from module2 import *

add(10, 20)

module2 add function
SUM: 30

# In the case of conflicts, python will always consider the most recent copy.

x = 10
print(x)
x = 20
print(x)
x = 30
print(x)

10
20
30

# The most recent copy ---> order wise which is avaialable at last.

# How to call module1 add function?

# Two Ways :-

# 1st way :-

import module1
import module2

module1.add(10, 20)
module2.add(10, 20)

module1 add function
SUM: 30
module2 add function
SUM: 30

# 2nd way :-

from module1 import add as m1
from module2 import add as m2

m1.add(10, 20)
m2.add(10, 20)

module1 add function
SUM: 30
module2 add function
SUM: 30

# # Reloading of Module :-

# import module will be loading only once in PVM whether you call it in multiple files multiple times.

# By default module will be loaded only once eventhough we are importing multiple times.

# Advantage :-
    # Performance is more

# Problem :-
    # We are missing updations of that module.

import module1

module1.add(10, 20)

module1 add function
SUM: 30

import module1

module1.add(10, 20)

module1 add function
SUM: 30

import time
import module1

module1.add(10, 20)
print("Progrsam Entering into Sleeping State")
time.sleep(45)
print("Just Wake up and calling Updated Fuction")
import module1

module1.product(10, 20)

module1 add function
SUM: 30
Progrsam Entering into Sleeping State
Just Wake up and calling Updated Fuction

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[52], line 10
      7 print("Just Wake up and calling Updated Fuction")
      8 import module1
---> 10 module1.product(10, 20)

AttributeError: module 'module1' has no attribute 'product'

# reload()
# imp module

import time
import imp
import module1

module1.add(10, 20)
print("Progrsam Entering into Sleeping State")
time.sleep(45)
print("Just Wake up and calling Updated Fuction")
imp.reload(module1)

module1.product(10, 20)

C:\Users\pulki\AppData\Local\Temp\ipykernel_7632\3697301949.py:2: DeprecationWarning: the imp module is deprecated in favour of importlib and slated for removal in Python 3.12; see the module's documentation for alternative uses
  import imp

module1 add function
SUM: 30
Progrsam Entering into Sleeping State
Just Wake up and calling Updated Fuction
PRODUCT : 200

# My Python Program keep on printing share price values.
# Some module is available to provide shares data.

# Without Reloading program if we run program second time updation is occur?

# PVM will be stopped
# PVM will be started again

# dir() and help() functions :-

# Finding Members of Module by using dir() function :-

# Just To list out members of a module

# dir() ---> To listout members of current module
# dir(module_name) ---> To listout members of specified module

a = 10
b = 20


def add(a, b):
    return a + b


def product(a, b):
    return a * b

# To listout all members of current module
print(dir())

['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__vsc_ipynb_file__', '_dh', '_i', '_i1', '_i2', '_i3', '_ih', '_ii', '_iii', '_oh', 'a', 'add', 'b', 'exit', 'get_ipython', 'module1', 'open', 'product', 'quit']

# For every module, PVM will add several predefined variables, which are internally used by PVM. Even these varaibles can be used by programmer based on his requirement.

# To list out all members of math module

import math

print(dir(math))

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

# Help documentation of a Module :-

# help()

import math

help(math)

Help on built-in module math:

NAME
    math

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.
        
        The result is between 0 and pi.
    
    acosh(x, /)
        Return the inverse hyperbolic cosine of x.
    
    asin(x, /)
        Return the arc sine (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    asinh(x, /)
        Return the inverse hyperbolic sine of x.
    
    atan(x, /)
        Return the arc tangent (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    atan2(y, x, /)
        Return the arc tangent (measured in radians) of y/x.
        
        Unlike atan(y/x), the signs of both x and y are considered.
    
    atanh(x, /)
        Return the inverse hyperbolic tangent of x.
    
    cbrt(x, /)
        Return the cube root of x.
    
    ceil(x, /)
        Return the ceiling of x as an Integral.
        
        This is the smallest integer >= x.
    
    comb(n, k, /)
        Number of ways to choose k items from n items without repetition and without order.
        
        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates
        to zero when k > n.
        
        Also called the binomial coefficient because it is equivalent
        to the coefficient of k-th term in polynomial expansion of the
        expression (1 + x)**n.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    copysign(x, y, /)
        Return a float with the magnitude (absolute value) of x but the sign of y.
        
        On platforms that support signed zeros, copysign(1.0, -0.0)
        returns -1.0.
    
    cos(x, /)
        Return the cosine of x (measured in radians).
    
    cosh(x, /)
        Return the hyperbolic cosine of x.
    
    degrees(x, /)
        Convert angle x from radians to degrees.
    
    dist(p, q, /)
        Return the Euclidean distance between two points p and q.
        
        The points should be specified as sequences (or iterables) of
        coordinates.  Both inputs must have the same dimension.
        
        Roughly equivalent to:
            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))
    
    erf(x, /)
        Error function at x.
    
    erfc(x, /)
        Complementary error function at x.
    
    exp(x, /)
        Return e raised to the power of x.
    
    exp2(x, /)
        Return 2 raised to the power of x.
    
    expm1(x, /)
        Return exp(x)-1.
        
        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
    
    fabs(x, /)
        Return the absolute value of the float x.
    
    factorial(n, /)
        Find n!.
        
        Raise a ValueError if x is negative or non-integral.
    
    floor(x, /)
        Return the floor of x as an Integral.
        
        This is the largest integer <= x.
    
    fmod(x, y, /)
        Return fmod(x, y), according to platform C.
        
        x % y may differ.
    
    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).
        
        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
    
    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.
        
        Assumes IEEE-754 floating point arithmetic.
    
    gamma(x, /)
        Gamma function at x.
    
    gcd(*integers)
        Greatest Common Divisor.
    
    hypot(...)
        hypot(*coordinates) -> value
        
        Multidimensional Euclidean distance from the origin to a point.
        
        Roughly equivalent to:
            sqrt(sum(x**2 for x in coordinates))
        
        For a two dimensional point (x, y), gives the hypotenuse
        using the Pythagorean theorem:  sqrt(x*x + y*y).
        
        For example, the hypotenuse of a 3/4/5 right triangle is:
        
            >>> hypot(3.0, 4.0)
            5.0
    
    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
        Determine whether two floating point numbers are close in value.
        
          rel_tol
            maximum difference for being considered "close", relative to the
            magnitude of the input values
          abs_tol
            maximum difference for being considered "close", regardless of the
            magnitude of the input values
        
        Return True if a is close in value to b, and False otherwise.
        
        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.
        
        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
        is, NaN is not close to anything, even itself.  inf and -inf are
        only close to themselves.
    
    isfinite(x, /)
        Return True if x is neither an infinity nor a NaN, and False otherwise.
    
    isinf(x, /)
        Return True if x is a positive or negative infinity, and False otherwise.
    
    isnan(x, /)
        Return True if x is a NaN (not a number), and False otherwise.
    
    isqrt(n, /)
        Return the integer part of the square root of the input.
    
    lcm(*integers)
        Least Common Multiple.
    
    ldexp(x, i, /)
        Return x * (2**i).
        
        This is essentially the inverse of frexp().
    
    lgamma(x, /)
        Natural logarithm of absolute value of Gamma function at x.
    
    log(...)
        log(x, [base=math.e])
        Return the logarithm of x to the given base.
        
        If the base not specified, returns the natural logarithm (base e) of x.
    
    log10(x, /)
        Return the base 10 logarithm of x.
    
    log1p(x, /)
        Return the natural logarithm of 1+x (base e).
        
        The result is computed in a way which is accurate for x near zero.
    
    log2(x, /)
        Return the base 2 logarithm of x.
    
    modf(x, /)
        Return the fractional and integer parts of x.
        
        Both results carry the sign of x and are floats.
    
    nextafter(x, y, /)
        Return the next floating-point value after x towards y.
    
    perm(n, k=None, /)
        Number of ways to choose k items from n items without repetition and with order.
        
        Evaluates to n! / (n - k)! when k <= n and evaluates
        to zero when k > n.
        
        If k is not specified or is None, then k defaults to n
        and the function returns n!.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    pow(x, y, /)
        Return x**y (x to the power of y).
    
    prod(iterable, /, *, start=1)
        Calculate the product of all the elements in the input iterable.
        
        The default start value for the product is 1.
        
        When the iterable is empty, return the start value.  This function is
        intended specifically for use with numeric values and may reject
        non-numeric types.
    
    radians(x, /)
        Convert angle x from degrees to radians.
    
    remainder(x, y, /)
        Difference between x and the closest integer multiple of y.
        
        Return x - n*y where n*y is the closest integer multiple of y.
        In the case where x is exactly halfway between two multiples of
        y, the nearest even value of n is used. The result is always exact.
    
    sin(x, /)
        Return the sine of x (measured in radians).
    
    sinh(x, /)
        Return the hyperbolic sine of x.
    
    sqrt(x, /)
        Return the square root of x.
    
    tan(x, /)
        Return the tangent of x (measured in radians).
    
    tanh(x, /)
        Return the hyperbolic tangent of x.
    
    trunc(x, /)
        Truncates the Real x to the nearest Integral toward 0.
        
        Uses the __trunc__ magic method.
    
    ulp(x, /)
        Return the value of the least significant bit of the float x.

DATA
    e = 2.718281828459045
    inf = inf
    nan = nan
    pi = 3.141592653589793
    tau = 6.283185307179586

FILE
    (built-in)

import random

help(random)

Help on module random:

NAME
    random - Random variable generators.

MODULE REFERENCE
    https://docs.python.org/3.11/library/random.html
    
    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
        bytes
        -----
               uniform bytes (values between 0 and 255)
    
        integers
        --------
               uniform within range
    
        sequences
        ---------
               pick random element
               pick random sample
               pick weighted random sample
               generate random permutation
    
        distributions on the real line:
        ------------------------------
               uniform
               triangular
               normal (Gaussian)
               lognormal
               negative exponential
               gamma
               beta
               pareto
               Weibull
    
        distributions on the circle (angles 0 to 2pi)
        ---------------------------------------------
               circular uniform
               von Mises
    
    General notes on the underlying Mersenne Twister core generator:
    
    * The period is 2**19937-1.
    * It is one of the most extensively tested generators in existence.
    * The random() method is implemented in C, executes in a single Python step,
      and is, therefore, threadsafe.

CLASSES
    _random.Random(builtins.object)
        Random
            SystemRandom
    
    class Random(_random.Random)
     |  Random(x=None)
     |  
     |  Random number generator base class used by bound module functions.
     |  
     |  Used to instantiate instances of Random to get generators that don't
     |  share state.
     |  
     |  Class Random can also be subclassed if you want to use a different basic
     |  generator of your own devising: in that case, override the following
     |  methods:  random(), seed(), getstate(), and setstate().
     |  Optionally, implement a getrandbits() method so that randrange()
     |  can cover arbitrarily large ranges.
     |  
     |  Method resolution order:
     |      Random
     |      _random.Random
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getstate__(self)
     |      Helper for pickle.
     |  
     |  __init__(self, x=None)
     |      Initialize an instance.
     |      
     |      Optional argument x controls seeding, as for Random.seed().
     |  
     |  __reduce__(self)
     |      Helper for pickle.
     |  
     |  __setstate__(self, state)
     |  
     |  betavariate(self, alpha, beta)
     |      Beta distribution.
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      Returned values range between 0 and 1.
     |  
     |  choice(self, seq)
     |      Choose a random element from a non-empty sequence.
     |  
     |  choices(self, population, weights=None, *, cum_weights=None, k=1)
     |      Return a k sized list of population elements chosen with replacement.
     |      
     |      If the relative weights or cumulative weights are not specified,
     |      the selections are made with equal probability.
     |  
     |  expovariate(self, lambd)
     |      Exponential distribution.
     |      
     |      lambd is 1.0 divided by the desired mean.  It should be
     |      nonzero.  (The parameter would be called "lambda", but that is
     |      a reserved word in Python.)  Returned values range from 0 to
     |      positive infinity if lambd is positive, and from negative
     |      infinity to 0 if lambd is negative.
     |  
     |  gammavariate(self, alpha, beta)
     |      Gamma distribution.  Not the gamma function!
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      
     |      The probability distribution function is:
     |      
     |                  x ** (alpha - 1) * math.exp(-x / beta)
     |        pdf(x) =  --------------------------------------
     |                    math.gamma(alpha) * beta ** alpha
     |  
     |  gauss(self, mu=0.0, sigma=1.0)
     |      Gaussian distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.  This is
     |      slightly faster than the normalvariate() function.
     |      
     |      Not thread-safe without a lock around calls.
     |  
     |  getstate(self)
     |      Return internal state; can be passed to setstate() later.
     |  
     |  lognormvariate(self, mu, sigma)
     |      Log normal distribution.
     |      
     |      If you take the natural logarithm of this distribution, you'll get a
     |      normal distribution with mean mu and standard deviation sigma.
     |      mu can have any value, and sigma must be greater than zero.
     |  
     |  normalvariate(self, mu=0.0, sigma=1.0)
     |      Normal distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.
     |  
     |  paretovariate(self, alpha)
     |      Pareto distribution.  alpha is the shape parameter.
     |  
     |  randbytes(self, n)
     |      Generate n random bytes.
     |  
     |  randint(self, a, b)
     |      Return random integer in range [a, b], including both end points.
     |  
     |  randrange(self, start, stop=None, step=1)
     |      Choose a random item from range(stop) or range(start, stop[, step]).
     |      
     |      Roughly equivalent to ``choice(range(start, stop, step))`` but
     |      supports arbitrarily large ranges and is optimized for common cases.
     |  
     |  sample(self, population, k, *, counts=None)
     |      Chooses k unique random elements from a population sequence.
     |      
     |      Returns a new list containing elements from the population while
     |      leaving the original population unchanged.  The resulting list is
     |      in selection order so that all sub-slices will also be valid random
     |      samples.  This allows raffle winners (the sample) to be partitioned
     |      into grand prize and second place winners (the subslices).
     |      
     |      Members of the population need not be hashable or unique.  If the
     |      population contains repeats, then each occurrence is a possible
     |      selection in the sample.
     |      
     |      Repeated elements can be specified one at a time or with the optional
     |      counts parameter.  For example:
     |      
     |          sample(['red', 'blue'], counts=[4, 2], k=5)
     |      
     |      is equivalent to:
     |      
     |          sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
     |      
     |      To choose a sample from a range of integers, use range() for the
     |      population argument.  This is especially fast and space efficient
     |      for sampling from a large population:
     |      
     |          sample(range(10000000), 60)
     |  
     |  seed(self, a=None, version=2)
     |      Initialize internal state from a seed.
     |      
     |      The only supported seed types are None, int, float,
     |      str, bytes, and bytearray.
     |      
     |      None or no argument seeds from current time or from an operating
     |      system specific randomness source if available.
     |      
     |      If *a* is an int, all bits are used.
     |      
     |      For version 2 (the default), all of the bits are used if *a* is a str,
     |      bytes, or bytearray.  For version 1 (provided for reproducing random
     |      sequences from older versions of Python), the algorithm for str and
     |      bytes generates a narrower range of seeds.
     |  
     |  setstate(self, state)
     |      Restore internal state from object returned by getstate().
     |  
     |  shuffle(self, x)
     |      Shuffle list x in place, and return None.
     |  
     |  triangular(self, low=0.0, high=1.0, mode=None)
     |      Triangular distribution.
     |      
     |      Continuous distribution bounded by given lower and upper limits,
     |      and having a given mode value in-between.
     |      
     |      http://en.wikipedia.org/wiki/Triangular_distribution
     |  
     |  uniform(self, a, b)
     |      Get a random number in the range [a, b) or [a, b] depending on rounding.
     |  
     |  vonmisesvariate(self, mu, kappa)
     |      Circular data distribution.
     |      
     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and
     |      kappa is the concentration parameter, which must be greater than or
     |      equal to zero.  If kappa is equal to zero, this distribution reduces
     |      to a uniform random angle over the range 0 to 2*pi.
     |  
     |  weibullvariate(self, alpha, beta)
     |      Weibull distribution.
     |      
     |      alpha is the scale parameter and beta is the shape parameter.
     |  
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |  
     |  __init_subclass__(**kwargs)
     |      Control how subclasses generate random integers.
     |      
     |      The algorithm a subclass can use depends on the random() and/or
     |      getrandbits() implementation available to it and determines
     |      whether it can generate random integers from arbitrarily large
     |      ranges.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables
     |  
     |  __weakref__
     |      list of weak references to the object
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  VERSION = 3
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from _random.Random:
     |  
     |  getrandbits(self, k, /)
     |      getrandbits(k) -> x.  Generates an int with k random bits.
     |  
     |  random(self, /)
     |      random() -> x in the interval [0, 1).
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from _random.Random:
     |  
     |  __new__(*args, **kwargs) class method of _random.Random
     |      Create and return a new object.  See help(type) for accurate signature.
    
    class SystemRandom(Random)
     |  SystemRandom(x=None)
     |  
     |  Alternate random number generator using sources provided
     |  by the operating system (such as /dev/urandom on Unix or
     |  CryptGenRandom on Windows).
     |  
     |   Not available on all systems (see os.urandom() for details).
     |  
     |  Method resolution order:
     |      SystemRandom
     |      Random
     |      _random.Random
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  getrandbits(self, k)
     |      getrandbits(k) -> x.  Generates an int with k random bits.
     |  
     |  getstate = _notimplemented(self, *args, **kwds)
     |  
     |  randbytes(self, n)
     |      Generate n random bytes.
     |  
     |  random(self)
     |      Get the next random number in the range 0.0 <= X < 1.0.
     |  
     |  seed(self, *args, **kwds)
     |      Stub method.  Not used for a system random number generator.
     |  
     |  setstate = _notimplemented(self, *args, **kwds)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Random:
     |  
     |  __getstate__(self)
     |      Helper for pickle.
     |  
     |  __init__(self, x=None)
     |      Initialize an instance.
     |      
     |      Optional argument x controls seeding, as for Random.seed().
     |  
     |  __reduce__(self)
     |      Helper for pickle.
     |  
     |  __setstate__(self, state)
     |  
     |  betavariate(self, alpha, beta)
     |      Beta distribution.
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      Returned values range between 0 and 1.
     |  
     |  choice(self, seq)
     |      Choose a random element from a non-empty sequence.
     |  
     |  choices(self, population, weights=None, *, cum_weights=None, k=1)
     |      Return a k sized list of population elements chosen with replacement.
     |      
     |      If the relative weights or cumulative weights are not specified,
     |      the selections are made with equal probability.
     |  
     |  expovariate(self, lambd)
     |      Exponential distribution.
     |      
     |      lambd is 1.0 divided by the desired mean.  It should be
     |      nonzero.  (The parameter would be called "lambda", but that is
     |      a reserved word in Python.)  Returned values range from 0 to
     |      positive infinity if lambd is positive, and from negative
     |      infinity to 0 if lambd is negative.
     |  
     |  gammavariate(self, alpha, beta)
     |      Gamma distribution.  Not the gamma function!
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      
     |      The probability distribution function is:
     |      
     |                  x ** (alpha - 1) * math.exp(-x / beta)
     |        pdf(x) =  --------------------------------------
     |                    math.gamma(alpha) * beta ** alpha
     |  
     |  gauss(self, mu=0.0, sigma=1.0)
     |      Gaussian distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.  This is
     |      slightly faster than the normalvariate() function.
     |      
     |      Not thread-safe without a lock around calls.
     |  
     |  lognormvariate(self, mu, sigma)
     |      Log normal distribution.
     |      
     |      If you take the natural logarithm of this distribution, you'll get a
     |      normal distribution with mean mu and standard deviation sigma.
     |      mu can have any value, and sigma must be greater than zero.
     |  
     |  normalvariate(self, mu=0.0, sigma=1.0)
     |      Normal distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.
     |  
     |  paretovariate(self, alpha)
     |      Pareto distribution.  alpha is the shape parameter.
     |  
     |  randint(self, a, b)
     |      Return random integer in range [a, b], including both end points.
     |  
     |  randrange(self, start, stop=None, step=1)
     |      Choose a random item from range(stop) or range(start, stop[, step]).
     |      
     |      Roughly equivalent to ``choice(range(start, stop, step))`` but
     |      supports arbitrarily large ranges and is optimized for common cases.
     |  
     |  sample(self, population, k, *, counts=None)
     |      Chooses k unique random elements from a population sequence.
     |      
     |      Returns a new list containing elements from the population while
     |      leaving the original population unchanged.  The resulting list is
     |      in selection order so that all sub-slices will also be valid random
     |      samples.  This allows raffle winners (the sample) to be partitioned
     |      into grand prize and second place winners (the subslices).
     |      
     |      Members of the population need not be hashable or unique.  If the
     |      population contains repeats, then each occurrence is a possible
     |      selection in the sample.
     |      
     |      Repeated elements can be specified one at a time or with the optional
     |      counts parameter.  For example:
     |      
     |          sample(['red', 'blue'], counts=[4, 2], k=5)
     |      
     |      is equivalent to:
     |      
     |          sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
     |      
     |      To choose a sample from a range of integers, use range() for the
     |      population argument.  This is especially fast and space efficient
     |      for sampling from a large population:
     |      
     |          sample(range(10000000), 60)
     |  
     |  shuffle(self, x)
     |      Shuffle list x in place, and return None.
     |  
     |  triangular(self, low=0.0, high=1.0, mode=None)
     |      Triangular distribution.
     |      
     |      Continuous distribution bounded by given lower and upper limits,
     |      and having a given mode value in-between.
     |      
     |      http://en.wikipedia.org/wiki/Triangular_distribution
     |  
     |  uniform(self, a, b)
     |      Get a random number in the range [a, b) or [a, b] depending on rounding.
     |  
     |  vonmisesvariate(self, mu, kappa)
     |      Circular data distribution.
     |      
     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and
     |      kappa is the concentration parameter, which must be greater than or
     |      equal to zero.  If kappa is equal to zero, this distribution reduces
     |      to a uniform random angle over the range 0 to 2*pi.
     |  
     |  weibullvariate(self, alpha, beta)
     |      Weibull distribution.
     |      
     |      alpha is the scale parameter and beta is the shape parameter.
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Random:
     |  
     |  __init_subclass__(**kwargs)
     |      Control how subclasses generate random integers.
     |      
     |      The algorithm a subclass can use depends on the random() and/or
     |      getrandbits() implementation available to it and determines
     |      whether it can generate random integers from arbitrarily large
     |      ranges.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Random:
     |  
     |  __dict__
     |      dictionary for instance variables
     |  
     |  __weakref__
     |      list of weak references to the object
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Random:
     |  
     |  VERSION = 3
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from _random.Random:
     |  
     |  __new__(*args, **kwargs) class method of _random.Random
     |      Create and return a new object.  See help(type) for accurate signature.

FUNCTIONS
    betavariate(alpha, beta) method of Random instance
        Beta distribution.
        
        Conditions on the parameters are alpha > 0 and beta > 0.
        Returned values range between 0 and 1.
    
    choice(seq) method of Random instance
        Choose a random element from a non-empty sequence.
    
    choices(population, weights=None, *, cum_weights=None, k=1) method of Random instance
        Return a k sized list of population elements chosen with replacement.
        
        If the relative weights or cumulative weights are not specified,
        the selections are made with equal probability.
    
    expovariate(lambd) method of Random instance
        Exponential distribution.
        
        lambd is 1.0 divided by the desired mean.  It should be
        nonzero.  (The parameter would be called "lambda", but that is
        a reserved word in Python.)  Returned values range from 0 to
        positive infinity if lambd is positive, and from negative
        infinity to 0 if lambd is negative.
    
    gammavariate(alpha, beta) method of Random instance
        Gamma distribution.  Not the gamma function!
        
        Conditions on the parameters are alpha > 0 and beta > 0.
        
        The probability distribution function is:
        
                    x ** (alpha - 1) * math.exp(-x / beta)
          pdf(x) =  --------------------------------------
                      math.gamma(alpha) * beta ** alpha
    
    gauss(mu=0.0, sigma=1.0) method of Random instance
        Gaussian distribution.
        
        mu is the mean, and sigma is the standard deviation.  This is
        slightly faster than the normalvariate() function.
        
        Not thread-safe without a lock around calls.
    
    getrandbits(k, /) method of Random instance
        getrandbits(k) -> x.  Generates an int with k random bits.
    
    getstate() method of Random instance
        Return internal state; can be passed to setstate() later.
    
    lognormvariate(mu, sigma) method of Random instance
        Log normal distribution.
        
        If you take the natural logarithm of this distribution, you'll get a
        normal distribution with mean mu and standard deviation sigma.
        mu can have any value, and sigma must be greater than zero.
    
    normalvariate(mu=0.0, sigma=1.0) method of Random instance
        Normal distribution.
        
        mu is the mean, and sigma is the standard deviation.
    
    paretovariate(alpha) method of Random instance
        Pareto distribution.  alpha is the shape parameter.
    
    randbytes(n) method of Random instance
        Generate n random bytes.
    
    randint(a, b) method of Random instance
        Return random integer in range [a, b], including both end points.
    
    random() method of Random instance
        random() -> x in the interval [0, 1).
    
    randrange(start, stop=None, step=1) method of Random instance
        Choose a random item from range(stop) or range(start, stop[, step]).
        
        Roughly equivalent to ``choice(range(start, stop, step))`` but
        supports arbitrarily large ranges and is optimized for common cases.
    
    sample(population, k, *, counts=None) method of Random instance
        Chooses k unique random elements from a population sequence.
        
        Returns a new list containing elements from the population while
        leaving the original population unchanged.  The resulting list is
        in selection order so that all sub-slices will also be valid random
        samples.  This allows raffle winners (the sample) to be partitioned
        into grand prize and second place winners (the subslices).
        
        Members of the population need not be hashable or unique.  If the
        population contains repeats, then each occurrence is a possible
        selection in the sample.
        
        Repeated elements can be specified one at a time or with the optional
        counts parameter.  For example:
        
            sample(['red', 'blue'], counts=[4, 2], k=5)
        
        is equivalent to:
        
            sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
        
        To choose a sample from a range of integers, use range() for the
        population argument.  This is especially fast and space efficient
        for sampling from a large population:
        
            sample(range(10000000), 60)
    
    seed(a=None, version=2) method of Random instance
        Initialize internal state from a seed.
        
        The only supported seed types are None, int, float,
        str, bytes, and bytearray.
        
        None or no argument seeds from current time or from an operating
        system specific randomness source if available.
        
        If *a* is an int, all bits are used.
        
        For version 2 (the default), all of the bits are used if *a* is a str,
        bytes, or bytearray.  For version 1 (provided for reproducing random
        sequences from older versions of Python), the algorithm for str and
        bytes generates a narrower range of seeds.
    
    setstate(state) method of Random instance
        Restore internal state from object returned by getstate().
    
    shuffle(x) method of Random instance
        Shuffle list x in place, and return None.
    
    triangular(low=0.0, high=1.0, mode=None) method of Random instance
        Triangular distribution.
        
        Continuous distribution bounded by given lower and upper limits,
        and having a given mode value in-between.
        
        http://en.wikipedia.org/wiki/Triangular_distribution
    
    uniform(a, b) method of Random instance
        Get a random number in the range [a, b) or [a, b] depending on rounding.
    
    vonmisesvariate(mu, kappa) method of Random instance
        Circular data distribution.
        
        mu is the mean angle, expressed in radians between 0 and 2*pi, and
        kappa is the concentration parameter, which must be greater than or
        equal to zero.  If kappa is equal to zero, this distribution reduces
        to a uniform random angle over the range 0 to 2*pi.
    
    weibullvariate(alpha, beta) method of Random instance
        Weibull distribution.
        
        alpha is the scale parameter and beta is the shape parameter.

DATA
    __all__ = ['Random', 'SystemRandom', 'betavariate', 'choice', 'choices...

FILE
    c:\users\pulki\anaconda3\envs\personal\lib\random.py

# help() will give detailed information.
# dir() will just list members of a module.

# Extra Members added by PVM for every Module :-

# For every module, PVM will add several prdefined variabled, which are internally used by PVM. Even these variables can be used by programmer based on his requirement.

# __doc__
# __file__
# __name__
# __loader__
# __package__

print(dir())

['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__vsc_ipynb_file__', '_dh', '_i', '_i1', '_i10', '_i11', '_i2', '_i3', '_i4', '_i5', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'a', 'add', 'b', 'exit', 'get_ipython', 'math', 'module1', 'open', 'product', 'quit', 'random']

print(__loader__)

None

print(__builtins__)

<module 'builtins' (built-in)>

print(__builtin__)

<module 'builtins' (built-in)>

print(__doc__)

Automatically created module for IPython interactive environment

print(__package__)

None

print(__vsc_ipynb_file__)

c:\Users\pulki\Python\python_fundamentals\65_Finding_Members_of_Modules.ipynb

# # __doc__ :-

# This variable holds documentation string.

""" This code is written by Pulkit Chahal """

print(__doc__)

 This code is written by Pulkit Chahal 

""" This code is written by Pulkit Chahal """
""" This code is written by Chahal """
""" This code is written by Pulkit """

print(__doc__)

 This code is written by Pulkit 

import math

print(math.__doc__)

This module provides access to the mathematical functions
defined by the C standard.

import random

print(random.__doc__)

Random variable generators.

    bytes
    -----
           uniform bytes (values between 0 and 255)

    integers
    --------
           uniform within range

    sequences
    ---------
           pick random element
           pick random sample
           pick weighted random sample
           generate random permutation

    distributions on the real line:
    ------------------------------
           uniform
           triangular
           normal (Gaussian)
           lognormal
           negative exponential
           gamma
           beta
           pareto
           Weibull

    distributions on the circle (angles 0 to 2pi)
    ---------------------------------------------
           circular uniform
           von Mises

General notes on the underlying Mersenne Twister core generator:

* The period is 2**19937-1.
* It is one of the most extensively tested generators in existence.
* The random() method is implemented in C, executes in a single Python step,
  and is, therefore, threadsafe.

# # __file__ :-

# To get the location of file.

print("File Name:", __file__)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[26], line 1
----> 1 print("File Name:", __file__)

NameError: name '__file__' is not defined

import os

print("Absolute Path:", os.path.abspath(__vsc_ipynb_file__))

Absolute Path: c:\Users\pulki\Python\python_fundamentals\65_Finding_Members_of_Modules.ipynb

print("Directory:", os.path.dirname(os.path.abspath(__vsc_ipynb_file__)))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[27], line 1
----> 1 print("Directory:", os.path.dirname(os.path.abspath(__vsc_ipynb_file__)))

NameError: name 'os' is not defined

# # __name__ :-

# py module1.py ===> Direct execution of module1.py
# py test.py ===> Indirect execution of module1.py

print(__name__)

__main__

import module1

print("test module")

test module

# Module1 file

print("Module1 Execution")

Module1 Execution

# __name__ ---> Magic Variable

# __name__
    # ===> Direct Execution : __main__
            # It means we are executing module1 as main program.

    # ===> Indirect Execution : modulename (module1)

# __name__ ===> __main__    (DE)
        # ===> module1      (IE)

if __name__ == '___main__':
    print('Executing Directly')
else:
    print('Executing Indiretly because of import statement')

Executing Indiretly because of import statement

# Module1 file
def f1():
    print("f1 function")


def f2():
    print("f2 function")


def f3():
    print("f3 function")


def f4():
    print("f4 function")


f1()
f2()
f3()
f4()

f1 function
f2 function
f3 function
f4 function

import module1

print("We required only some functions but not all")
module1.f1()

We required only some functions but not all
f1 function

# # Working with Random Module :-

# Random module contains several functions to generate random numbers.

# Developing Games
# Cryptography
# OTP
# Random password

# 1. random()
# 2. uniform()
# 3. randint()
# 4. randrange()
# 5. choice()

# 1. random() :-

# generate some float values between 0 and 1 (not inclusive)

# 0.9999345
# 0.1234878

from random import *

print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())

0.6464542100401829
0.010675848165000446
0.626119271169842
0.9968781442082784
0.008614968664742984
0.589771783023502
0.409783533525354
0.8431020634036197
0.48870048075470374
0.3819780839674809
0.12230734210818128

# 2. uniform() :-

# To generate random float vlaue between 2 given numbers (not inclusive)

# uniform(1,10)

from random import *

for i in range(10):
    print(uniform(1, 10))

3.1347665605027677
6.814167460300179
9.507224080637071
7.45048372921796
1.670982266184999
5.7269930756381235
2.172093103180653
2.317205953537269
4.6647954685826205
5.140179460010281

# 3. randint() :-

# To generate a random interger between 2 given numbers (inclusive)

# randint(1, 10) ---> 1 to 10 including 1 and 10

from random import *

for i in range(10):
    print(randint(1, 10))

1
5
8
7
7
5
1
10
5
3

# 4. randrange([begin], end, [step]) :-

# Returns a random number from range
    # begin <= x < end

# begin is optional and default value is 0.
# step is optional and default value is 1.

# randrane(10) ---> generates a random number from 0 to 9
# randrange(1, 10) ---> generates a random number from 1 to 10
# randrange(1, 11, 2) ---> generates a random number from 1 to 10 by increment of 2
                        # [1, 3, 5, 7, 9]

# randrange(0, 11, 2) ---> generates a random number from 0 to 10 by increment of 2
                        # [0, 2, 4, 6, 8]

from random import *

for i in range(10):
    print(randrange(10))

8
1
1
5
5
9
6
7
4
6

from random import *

for i in range(10):
    print(randrange(1, 11))

4
3
2
4
5
7
6
8
3
2

from random import *

for i in range(10):
    print(randrange(1, 11, 2))

5
3
3
1
3
3
5
3
7
5

from random import *

for i in range(10):
    print(randrange(0, 11, 2))

2
2
10
0
0
6
10
0
6
8

# 5. choice() :-

# It won't generate random number.
# It will generate a random object from the given sequence.

from random import *

l = ["Sunny", "Bunny", "Chinny", "Vinny", "Pinny"]

for i in range(10):
    print(choice(l))

Vinny
Chinny
Pinny
Bunny
Chinny
Pinny
Sunny
Pinny
Pinny
Sunny

from random import *

alphabets = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

for i in range(10):
    print(choice(alphabets))

S
W
W
K
Y
G
n
y
a
B

# 1. To genrate 6-digit random number which can be used as OTP?

from random import *

print(
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
)

5 4 0 4 5 3

from random import *

print(
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    sep="",
)

092666

from random import *

for i in range(10):
    print(
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        sep="",
    )

239368
411586
955018
891601
161595
783737
720103
579960
681697
663860

# 2. Random pwd of 6 length?

# where 1, 3, 5 are alphabet symbols
# 2, 4, 6 are digits

from random import *

alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
digits = "0123456789"

for i in range(10):
    print(
        choice(alphabets)
        + choice(digits)
        + choice(alphabets)
        + choice(digits)
        + choice(alphabets)
        + choice(digits)
    )

B2E3X5
H2H4F1
T1Y7F0
V0M0H4
G1G4E6
V4A5S8
P7J2S1
W0T9N3
L7B5X5
O1U3M0

from random import *

alphabets = "abcdefghijklmnopqrstuvwxyz"
digits = "0123456789"
cities = ["Hyderabad", "Chennai", "Banglore", "Pune", "Delhi", "Mumbai"]
designations = [
    "Software Engineer",
    "Senior Software Engineer",
    "Team Lead",
    "Project Manager",
    "Project Lead",
]


def get_fake_name():
    name = choice(alphabets).upper()
    n = randint(2, 6)
    for i in range(n):
        name = name + choice(alphabets)
    return name


def get_fake_eno():
    eno = "e-"
    for i in range(4):
        eno = eno + str(randint(0, 9))
    return eno


def get_fake_salary():
    esal = uniform(10000, 50000)
    return esal


def get_fake_city():
    city = choice(cities)
    return city


def get_fake_mno():
    mno = choice("6789")
    for i in range(9):
        mno = mno + choice(digits)
    return mno


def get_fake_designation():
    designation = choice(designations)
    return designation


def get_fake_emp_data():
    print("Employee Name :", get_fake_name())
    print("Employee Number :", get_fake_eno())
    print("Employee Salary : {:.2f}".format(get_fake_salary()))
    print("Employee City :", get_fake_city())
    print("Employee Mobile Number :", get_fake_mno())
    print("Employee Designation :", get_fake_designation())


get_fake_emp_data()

Employee Name : Wefp
Employee Number : e-0714
Employee Salary : 26959.20
Employee City : Mumbai
Employee Mobile Number : 7147705020
Employee Designation : Project Lead

for i in range(3):
    get_fake_emp_data()

Employee Name : Blysth
Employee Number : e-8084
Employee Salary : 18230.72
Employee City : Banglore
Employee Mobile Number : 7672497334
Employee Designation : Project Lead
Employee Name : Cdxvdsr
Employee Number : e-8162
Employee Salary : 10383.68
Employee City : Pune
Employee Mobile Number : 8985711489
Employee Designation : Project Lead
Employee Name : Axaz
Employee Number : e-1870
Employee Salary : 16295.46
Employee City : Delhi
Employee Mobile Number : 6993463914
Employee Designation : Team Lead

# # Working with Math Module :-

# Math module defines several functions which can be used for mathematical operations.

# sqrt(x)
# ceil(x)
# floor(x)
# fabs(x)
# log(x)
# sin(x)
# tan(x)

from math import *

print(sqrt(4))

2.0

print(ceil(10.1))

11

print(ceil(10.5))

11

print(floor(10.1))

10

print(floor(10.4))

10

print(floor(10.5))

10

print(floor(10.6))

10

print(fabs(10.6))

10.6

print(fabs(-10.6))

10.6

import math

help(math)

Help on built-in module math:

NAME
    math

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.
        
        The result is between 0 and pi.
    
    acosh(x, /)
        Return the inverse hyperbolic cosine of x.
    
    asin(x, /)
        Return the arc sine (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    asinh(x, /)
        Return the inverse hyperbolic sine of x.
    
    atan(x, /)
        Return the arc tangent (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    atan2(y, x, /)
        Return the arc tangent (measured in radians) of y/x.
        
        Unlike atan(y/x), the signs of both x and y are considered.
    
    atanh(x, /)
        Return the inverse hyperbolic tangent of x.
    
    cbrt(x, /)
        Return the cube root of x.
    
    ceil(x, /)
        Return the ceiling of x as an Integral.
        
        This is the smallest integer >= x.
    
    comb(n, k, /)
        Number of ways to choose k items from n items without repetition and without order.
        
        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates
        to zero when k > n.
        
        Also called the binomial coefficient because it is equivalent
        to the coefficient of k-th term in polynomial expansion of the
        expression (1 + x)**n.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    copysign(x, y, /)
        Return a float with the magnitude (absolute value) of x but the sign of y.
        
        On platforms that support signed zeros, copysign(1.0, -0.0)
        returns -1.0.
    
    cos(x, /)
        Return the cosine of x (measured in radians).
    
    cosh(x, /)
        Return the hyperbolic cosine of x.
    
    degrees(x, /)
        Convert angle x from radians to degrees.
    
    dist(p, q, /)
        Return the Euclidean distance between two points p and q.
        
        The points should be specified as sequences (or iterables) of
        coordinates.  Both inputs must have the same dimension.
        
        Roughly equivalent to:
            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))
    
    erf(x, /)
        Error function at x.
    
    erfc(x, /)
        Complementary error function at x.
    
    exp(x, /)
        Return e raised to the power of x.
    
    exp2(x, /)
        Return 2 raised to the power of x.
    
    expm1(x, /)
        Return exp(x)-1.
        
        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
    
    fabs(x, /)
        Return the absolute value of the float x.
    
    factorial(n, /)
        Find n!.
        
        Raise a ValueError if x is negative or non-integral.
    
    floor(x, /)
        Return the floor of x as an Integral.
        
        This is the largest integer <= x.
    
    fmod(x, y, /)
        Return fmod(x, y), according to platform C.
        
        x % y may differ.
    
    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).
        
        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
    
    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.
        
        Assumes IEEE-754 floating point arithmetic.
    
    gamma(x, /)
        Gamma function at x.
    
    gcd(*integers)
        Greatest Common Divisor.
    
    hypot(...)
        hypot(*coordinates) -> value
        
        Multidimensional Euclidean distance from the origin to a point.
        
        Roughly equivalent to:
            sqrt(sum(x**2 for x in coordinates))
        
        For a two dimensional point (x, y), gives the hypotenuse
        using the Pythagorean theorem:  sqrt(x*x + y*y).
        
        For example, the hypotenuse of a 3/4/5 right triangle is:
        
            >>> hypot(3.0, 4.0)
            5.0
    
    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
        Determine whether two floating point numbers are close in value.
        
          rel_tol
            maximum difference for being considered "close", relative to the
            magnitude of the input values
          abs_tol
            maximum difference for being considered "close", regardless of the
            magnitude of the input values
        
        Return True if a is close in value to b, and False otherwise.
        
        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.
        
        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
        is, NaN is not close to anything, even itself.  inf and -inf are
        only close to themselves.
    
    isfinite(x, /)
        Return True if x is neither an infinity nor a NaN, and False otherwise.
    
    isinf(x, /)
        Return True if x is a positive or negative infinity, and False otherwise.
    
    isnan(x, /)
        Return True if x is a NaN (not a number), and False otherwise.
    
    isqrt(n, /)
        Return the integer part of the square root of the input.
    
    lcm(*integers)
        Least Common Multiple.
    
    ldexp(x, i, /)
        Return x * (2**i).
        
        This is essentially the inverse of frexp().
    
    lgamma(x, /)
        Natural logarithm of absolute value of Gamma function at x.
    
    log(...)
        log(x, [base=math.e])
        Return the logarithm of x to the given base.
        
        If the base not specified, returns the natural logarithm (base e) of x.
    
    log10(x, /)
        Return the base 10 logarithm of x.
    
    log1p(x, /)
        Return the natural logarithm of 1+x (base e).
        
        The result is computed in a way which is accurate for x near zero.
    
    log2(x, /)
        Return the base 2 logarithm of x.
    
    modf(x, /)
        Return the fractional and integer parts of x.
        
        Both results carry the sign of x and are floats.
    
    nextafter(x, y, /)
        Return the next floating-point value after x towards y.
    
    perm(n, k=None, /)
        Number of ways to choose k items from n items without repetition and with order.
        
        Evaluates to n! / (n - k)! when k <= n and evaluates
        to zero when k > n.
        
        If k is not specified or is None, then k defaults to n
        and the function returns n!.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    pow(x, y, /)
        Return x**y (x to the power of y).
    
    prod(iterable, /, *, start=1)
        Calculate the product of all the elements in the input iterable.
        
        The default start value for the product is 1.
        
        When the iterable is empty, return the start value.  This function is
        intended specifically for use with numeric values and may reject
        non-numeric types.
    
    radians(x, /)
        Convert angle x from degrees to radians.
    
    remainder(x, y, /)
        Difference between x and the closest integer multiple of y.
        
        Return x - n*y where n*y is the closest integer multiple of y.
        In the case where x is exactly halfway between two multiples of
        y, the nearest even value of n is used. The result is always exact.
    
    sin(x, /)
        Return the sine of x (measured in radians).
    
    sinh(x, /)
        Return the hyperbolic sine of x.
    
    sqrt(x, /)
        Return the square root of x.
    
    tan(x, /)
        Return the tangent of x (measured in radians).
    
    tanh(x, /)
        Return the hyperbolic tangent of x.
    
    trunc(x, /)
        Truncates the Real x to the nearest Integral toward 0.
        
        Uses the __trunc__ magic method.
    
    ulp(x, /)
        Return the value of the least significant bit of the float x.

DATA
    e = 2.718281828459045
    inf = inf
    nan = nan
    pi = 3.141592653589793
    tau = 6.283185307179586

FILE
    (built-in)

a = -12.99

print(floor(fabs(a)))

12

a = -12.99

print(fabs(floor(a)))

13.0

import math

l = [str(round(math.pi)) for i in range(1, 6)]
print(l)

['3', '3', '3', '3', '3']

round(3.4)

3

round(3.5)

4

round(3.6)

4

# Modules :-
    # random
    # selenium
    # faker
    # math
    # os
    # re

# Functions :-
    # A group of repeatedly required lines
    # Code Reusability

# Modules :-
    # Python File
    # A group of functions, varibales, classes saved to a file

# # Packages :-

# Basic Java Package
    # core java + advanced java + oracle

# Complete Python Package
    # Core Python + Advanced Python + UI + Django + Django Rest Framework + Microsoft Certification

# Complete Body Checkup Package

# Hear Checkup Package

# South India Tour Package
    # 10 places

# A collection of python lines into a single unit ---> Function

# A collection of python functions, variable and classes into a single file ---> Module

# A collection of related modules into a folder ---> Package

# A collection of related modules into a single unit is nothing but package.

# Package is an encapsulation mechansim to group related modules into a single unit.

# Package is simply a folder or directory.

# If folder contains __init__.py file is considered as python package.

# A python package can contains sub package also but all packages should contain __init__.py file.

# From Python 3.3 version onwards, it is not mandatory to have __init__.py file.

# Advantages of Packages :-
    # 1. We can resolve naming conflicts.
    # 2. We can identify our components uniquely.
    # 3. It imporoves modularity of the application.
    # 4. It improves readability and maintainability of the applications.

# C:\Python
    # |-test.py
    # |-com
        # |-__init__.py
        # |-module1.py (contains f1 function)
        # |-durgasoft
            # |-__init__.py
            # |-module2.py (contains f2 function)

# from com.module1 import f1

# f1()

# from com.durgasoft.module2 import f2

# f2()

# Importance of init.py File :-

# At the time of using a package, if we want to perform any initialization activites automatically then we have to go for __init__.py

# but if we write print statement in noraml module also it will be executed? 
# but we have to call the function in which print statement while in __init__.py it will be executed automatically.

# If we have __init__.py file in folder and subfolder then.

# when we call folder then only folder __init__.py will execute
    # ex. from com.module import f1
        # in this only folder __init__.py file will execute automatically

# when we call sub-folder then folder and sub-folder __init__.py will execute
    # ex. from com.durgasoft.module2 import f1
        # in this folder and sub-folder __init__.py file will execute automatically

# Need of Installing a Package :-

# If we wnat to use a package, compulsory it should be available in the current working directory.

# To make package available through out our system then we have to install that package. Once we installed we can access that package from anywhere in our system.

# exec('function_name')

# How to Install Package :-

# from setuptools import setup

# setup(name="patterns", version="1.0", packages=["patterns"])

# pip is a python package management system to install and manage software packages written in python.

# pip install .

# # Alternative Way :-

# from setuptools import setup, find_packages

# setup(name="patterns", version="1.0", packages=find_packages())

# pip uninstall patterns

# pip install django (installing django library)
# pip install pymysql
# pip install selenium (for automation)

# pip ---> python package management software system
# npm ---> javascript
# apt ---> Ubuntu
# yum ---> redhat linux

# # Library vs Package vs Module vs Function :-

# Function ---> A group of repeatedly required lines of code.
# Module ---> A group of repeatedly required functions, variables, classes saved to a file.
# Package ---> A group of related modules into a single folder. It contains sub packages.
# Library ---> A group of packages.

# # File Handling :-

# We required to store data
    # student marks
    # customers account information
    # billing information

# Files are very common permanent storage areas to store our data.

# list, tuple, set, dict ===> available as long as program is in running. Once program completes these objects will be destroyed automatically and hence the data will be gone. Temporary storage areas.

d = {}

for i in range(3):
    name = input("Enter Name :")
    balance = int(input("Enter Balance :"))
    d[name] = balance

print(d)

{'asdbj': 45, 'dsafda': 2452, 'asdfas4': 24}

# Permanent Storage Areas :-
    # files
    # database
    # big data technologies/cloud

# Types of Files :-

# 2 Types of Files :-
    # 1. text files :
        # abc.txt, test.py

    # 2. Binary Files:
        # images, video files, audio files etc

# Opening of a File :-

# f = open(filename, mode)

# Example :-

f = open("abc.txt", "r")
data = f.read()
print(data)

This is Python Practice

# # The allowed modes are:
    # r, w, a, r+, w+, a+, x

# 1. r :-

# Open an existing file for read operation. The file pointer is at begining of the file.
# FileNotFoundError
# default mode is red mode

# 2. w :-

# Open an existing file for write operation.
# Overwrite of existing data will be happened.
# If the specified file not already availabel, then this mode will create that file.

f = open('abc.txt', 'w')

# 3. a :-

# Open an existing file for append operation.
# It won't overwrite of existing data will be happened.
# If the specified file not already availabel, then this mode will create that file.

# 4. r+ :-

# To read and write data.
# The previous data won't be overwritten.

# 5. w+ :-

# To write and read data.
# It will overwrite existing data.

# 6. a+ :-

# It append and read.
# It won't overwrite existing data.

# 7. x :-

# To open a file in exclusive createion mode.
# Specified file should not be avaialable already, otherwise we will get FileExistsError

# # 2. Binary File :-

# rb
# wb
# ab
# r+b
# w+b
# a+b
# xb

# Closing of a File :-

f.close()

# Various Properties of File Object :-

f = open("abc.txt", "r")

# f.name ---> Name of opened File
# f.module ---> Mode in which we opened that file.
# f.closed ---> Is the file closed (True/False)
# f.readable() ---> Returns True if the file is readable
# f.wrtable() ---> Returns True if the file is writable

f = open("abc.txt", "r")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : r
Is File Readable : True
Is File Writable : False
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "w")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : w
Is File Readable : False
Is File Writable : True
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "r+")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : r+
Is File Readable : True
Is File Writable : True
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "w+")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : w+
Is File Readable : True
Is File Writable : True
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "a")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : a
Is File Readable : False
Is File Writable : True
Is File Closed : False
Is File Closed : True

# Write Data to the text Files :-

# 2 METHODS :-
    # f.write(str)
    # f.writelines(list of lines)

f = open("abc.txt", "w")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w+")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "r+")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

# Data will be written in existing file without resenting file

f = open("abc.txt", "a+")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

# Data will be written in existing file without resenting file

f = open("abc.txt", "a")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "x")

f.write("Durga ")
f.write("Software ")
f.write("Solutions ")
print("Data Written to the File Successfully")
f.close()

---------------------------------------------------------------------------
FileExistsError                           Traceback (most recent call last)
Cell In[18], line 1
----> 1 f = open("abc.txt", "x")
      3 f.write("Durga ")
      4 f.write("Software ")

File c:\Users\pulki\anaconda3\envs\Personal\Lib\site-packages\IPython\core\interactiveshell.py:324, in _modified_open(file, *args, **kwargs)
    317 if file in {0, 1, 2}:
    318     raise ValueError(
    319         f"IPython won't let you open fd={file} by default "
    320         "as it is likely to crash IPython. If you know what you are doing, "
    321         "you can use builtins' open."
    322     )
--> 324 return io_open(file, *args, **kwargs)

FileExistsError: [Errno 17] File exists: 'abc.txt'

# f.writelines(list of lines) :-

f = open("abc.txt", "w")
l = ["Bunny", "Chinny", "Sunny", "Pinny", "Vinny"]

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w")
l = ["Bunny\n", "Chinny\n", "Sunny\n", "Pinny\n", "Vinny\n"]

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

# write(str)

# multiple strings ---> multiple write() methods
# writelines(list|ste|tuple|dict)

f = open("abc.txt", "w")
l = ("Bunny\n", "Chinny\n", "Sunny\n", "Pinny\n", "Vinny")

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w")
l = {"Bunny\n", "Chinny\n", "Sunny\n", "Pinny\n", "Vinny"}

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

# for set order wise no guaranttee

Data Written to the File Successfully

f = open("abc.txt", "w")
l = {"A": 100, "B": 200, "C": 300}

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w")
l = {100: "A", 200: "B", 300: "C"}

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[28], line 4
      1 f = open("abc.txt", "w")
      2 l = {100: "A", 200: "B", 300: "C"}
----> 4 f.writelines(l)
      6 print("Data Written to the File Successfully")
      7 f.close()

TypeError: write() argument must be str, not int

f = open("C:\\GNA\\abc.txt", "w")

f.write("First Line\n")
f.write("Second Line\n")
f.write("Third Line\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

fname = input("Enter File Name:")
f = open("C:\\GNA\\" + fname + ".txt", "w")

while True:
    data = input("Enter Data to Write:")
    f.write(data + "\n")
    option = input("Do you want to add some more data[Yes|No]:")
    if option.lower() == "no":
        break

print("Your Provided Data Written to the File Successfully")

f = open("C:\\GNA\\" + fname + ".txt", "r")
print(f.read())

f.close()

Your Provided Data Written to the File Successfully
durga
software
solutions

# Reading Data from Files :-

# read()    ---> To read total data from the file
# read(n)   ---> To read n characters from the file
# readline()    ---> To read only one line
# readlines()   ---> To read all lines into a list

f = open("abc.txt", "r")
data = f.read()
print(data)

Sunny
Bunny
Chinny
Vinny
Pinny
Munny

f = open("abc.txt", "r")
data = f.read(10)
print(data)

Sunny
Bunn

f = open("abc.txt", "r")
data = f.readline()
print(data)

Sunny

f = open("abc.txt", "r")
data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

Sunny

Bunny

Chinny

Vinny

Pinny

Munny

data = f.readline()
print(data)

data = f.readline()
print(data)

# After lines are finished while using f.readline() then it will keep on reading/printing empty lines.

# f.readline() will automatically add new empty line after each new line.

f = open("abc.txt", "r")
data = f.readlines()
print(data)

['Sunny\n', 'Bunny\n', 'Chinny\n', 'Vinny\n', 'Pinny\n', 'Munny']

f = open("abc.txt", "r")

line = f.readline()
while line != "":
    print(line)
    line = f.readline()

f.close()

Sunny

Bunny

Chinny



Vinny

Pinny

Munny

f = open("abc.txt", "r")

line = f.readline()
while line != "":
    print(line, end="")
    line = f.readline()

f.close()

Sunny
Bunny
Chinny

Vinny
Pinny
Munny

f = open("abc.txt", "r")

line = f.readline()
while line != "":
    if line != "\n":
        print(line, end="")
    line = f.readline()

f.close()

Sunny
Bunny
Chinny
Vinny
Pinny
Munny

f = open("abc.txt", "r")
data = f.readlines()
print(data)

['Sunny\n', 'Bunny\n', 'Chinny\n', '\n', 'Vinny\n', 'Pinny\n', 'Munny']

f = open("abc.txt", "r")
data = f.readlines()
print(data)

for line in data:
    print(line)

['Sunny\n', 'Bunny\n', 'Chinny\n', '\n', 'Vinny\n', 'Pinny\n', 'Munny']
Sunny

Bunny

Chinny



Vinny

Pinny

Munny

f = open("abc.txt", "r")
data = f.readlines()
print(data)

for line in data:
    print(line, end="")

['Sunny\n', 'Bunny\n', 'Chinny\n', '\n', 'Vinny\n', 'Pinny\n', 'Munny']
Sunny
Bunny
Chinny

Vinny
Pinny
Munny

f = open("abc.txt", "r")

print(f.read(3))
print(f.readline())
print(f.read(4))
print(f.read())

Sun
ny

Bunn
y
Chinny

Vinny
Pinny
Munny

# Read data from input.txt and write to output.txt?

f1 = open("input.txt", "r")
f2 = open("output.txt", "w")

data = f1.read()
f2.write(data)

f1.close()
f2.close()

print("Data Copied Successfully")

Data Copied Successfully

# with statement :-

with open("abc.txt", "w") as f:
    f.write("DURGA\n")
    f.write("SOFTWARE\n")
    f.write("SOLUTIONS\n")
    print("Is File Closed:", f.closed)

print("Is File Closed:", f.closed)

Is File Closed: False
Is File Closed: True

# When we use with statement file will be closed automatically we are not required to close the file.

# The file will close automatically when we are out of with statement.

f1 = open("abc.txt", "w")
f2 = open("abc.txt", "a")

f2.write("hello")
f1.write("Hi")

f2.close()
f1.close()

with open("abc.txt", "r") as f:
    print(f.read())

Hihellohello

# # Advantages of with statement :-
    # 1. To group file operation in a block
    # 2. To close the file automatically

# # # Rules to Define Identifiers in Python :-

# 1. Allowed Characters in Python :-
    # a to z
    # A to Z
    # 0 to 9
    # _(Underscore)

cash = 10

cas$h = 10

  Cell In[4], line 1
    cas$h = 10
       ^
SyntaxError: invalid syntax

cash_amount = 10

# 2. Identifier should not start with digit

total123 = 100

123total = 100

  Cell In[8], line 1
    123total = 100
      ^
SyntaxError: invalid decimal literal

# 3. Python identifiers are case sensitive

total = 10

Total = 20

TOTAL = 30

# 4. no length limit, but not recommended to take lengthy identifiers

# 5. we cannot use keyword or reserved characters as identifiers

x = 10

if = 20

  Cell In[29], line 1
    if = 20
       ^
SyntaxError: invalid syntax

# # Note :- 
    # x --> normal variable or public variable
    # _x --> protected variable
    # __x --> private variable
    
    # __x__ --> magical word
    # ex. __name__, __add__, __doc__, __sub__

__x = 10
type(__x)

int

# # # Reserved Words :-

# Some words are reserved to represent some functionality or meaning

# We have only 35 reserved words in Python

# True, False, None ===> Values.Reserved Literals

# and, or, not, is

# if, elif, else

# while, for, break, continue, return, in, yield

# try, except, finally, raise, assert

# import, from, as, class, def, pass, global, nonlocal, lambda, del, with

# # In Python 3.5 version new keyword introduced in Python :-

# async, await

# For asynchronous processing

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

# 1. All reserved words contain only alphabet symbols

# 2. The only reserved words contain upper case aplhabet symbol
#       True, False, None

# 3. Switch statement is not applicable in Python

# 4. do-while loop is not there

# 5. no keywords like int, float, boolean etc

# # # Data Types :-

# Data Type Represent the type of data represented by a variable

x = 10
x = True
x = 10.5
# Dynamically Typed: Python, JavaScript, ShellScripting etc

# int x = 10;
# boolean b = true;
# Statically Typed: Java, C, C++

# # Types of Data Types :-
    # int
    # float
    # complex
    # bool
    # str
    
    # list
    # tuple
    # set
    # frozenset
    # dict
    
    # bytes
    # bytearray
    # range
    # None

# # The 3 most commonly used in python's in built functions :-

# In Linux everything is treated as a File
# In Python everything is treated as Object

# x = 10
# 1. print(x)
# 2. type(x)
# 3. id(x) -->Address of Object

x = 10

print(x)

10

type(x)

int

id(x)

140731415577672

x = [10, 20, 30, 40, 50, 60, 70, 80]

print(x)
print(type(x))
print(id(x))

[10, 20, 30, 40, 50, 60, 70, 80]
<class 'list'>
2362951932544

# # # int Data Type :-

# To represent integral values

x = 10
print(type(x))

<class 'int'>

# # In Java we have :-

    # byte: -128 to +127
    # short: -32768 to 32767
    # int: -2147483648 to 2147483647
    # long: -2^63 to 2^63-1

x = 12134154687464634163746743216546874316574687431324865746431349874674321658746

# We have only 2 data types :-
    # int
    # long

# # Note :- In Python 2 we have int and long data type but in Python 3 we have only int data type

# # We can represent int values in multiple ways :-

    # 1. Decimal Form(base-10)
    # 2. Binary Form(base-2)
    # 3. Octal Form(base-8)
    # 4. Hexa Decimal Form(base-16)

# # 1. Decimal Form(base-10) :-

# The allowed digits are 0 to 9

# Example:
    # x = 12345

# # 2. Binary Form(base-2) :-

# The allowed digits are 0 to 1
# The number should be prefixed with 0b or 0B

# Example:
    # a = 0B1111
    # a = 0b1111

a = 1111
b = 0b1111

print(a)
print(b)

print(type(a))
print(type(b))

1111
15
<class 'int'>
<class 'int'>

# Convert Binary to Integer :-

    # ( 1    1    1    1 ) = (?)
    #  2^3  2^2  2^1  2^0

    # 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0
    # 1*8 + 1*4 + 1*2 + 1*1
    # 8 + 4 + 2 + 1
    # => 15

# # 3. Octal Form(base-8) :-

# The allowed digits are 0 to 7
# The number should be prefixed with 0o or 0O

# Example:
    # a = 0O0123
    # a = 0o0123

a = 0o0123
b = 0O0123

print(a)
print(b)

print(type(a))
print(type(b))

83
83
<class 'int'>
<class 'int'>

# Convert Octal to Integer :-

    # ( 0    1    2    3 ) = (?)
    #  8^3  8^2  8^1  8^0

    # 0*8^3 + 1*8^2 + 2*8^1 + 3*8^0
    # 0*512 + 1*64 + 2*8 + 3*1
    # 0 + 64 + 16 + 3
    # => 83

a = 0o123
b = 0b11

print(a)
print(b)

print(a + b)

83
3
86

# # 4. Hexa Decimal Form(base-16) :-

# The allowed digits are:
# 0 to 9, A to F

# A-->10
# B-->11
# C-->12
# D-->13
# E-->14
# F-->15

# A - F or a - f

# The number should be prefixed with 0x or 0X

# Example:
    # a = 0x0123Face
    # a = 0X0123Face

a = 0x0123Face
b = 0X0123Face

print(a)
print(b)

print(type(a))
print(type(b))

19135182
19135182
<class 'int'>
<class 'int'>

# Base-2 0 to 1
# Base-8 0 to 7
# Base-10 0 to 9
# Base-16 0 to 15

a = 0X012
print(a)

18

# Convert Hexa Decimal to Integer :-

    # (  0     1     2 ) = (?)
    #  16^2  16^1  16^0

    # 0*16^2 + 1*16^1 + 2*16*0
    # 0*256 + 1*16 + 2*1
    # 0 + 16 + 2
    # => 18

# # Base Conversion Functions :-

    # 1. bin()
    # 2. oct()
    # 3. hex()

# bin(x)--> Provides Equivalent Binary Value

# x can be any value like ocatl or decimal or hexa decimal number

a = 10
print(a)

b = bin(a)
print(b)

10
0b1010

print(bin(10))
print(bin(0o10))
print(bin(0x10))

0b1010
0b1000
0b10000

print(oct(10))

0o12

print(hex(10))

0xa

# # # Float Data Type :-

# Number with decimal point

f = 1.023

f = 0b1.1101

  Cell In[5], line 1
    f = 0b1.1101
           ^
SyntaxError: invalid syntax

f = 0o1.1101

  Cell In[6], line 1
    f = 0o1.1101
           ^
SyntaxError: invalid syntax

f = 0x1.1101

  Cell In[7], line 1
    f = 0x1.1101
           ^
SyntaxError: invalid syntax

# Float values we should specify only in decimal format

# Exponential form or Scientific notation
f = 1.2e3
print(f)

1200.0

f = 1.2E3
print(f)

1200.0

# We can represent big values in less memory

a = 120000000000000000000000000000000000000
print(a)

b = 12e16
print(b)

120000000000000000000000000000000000000
1.2e+17

# Conditions for Float Data Type :-

# 1. with decimal point
# 2. only in decimal
# 3. exponential form

# # # Complex Data Type :-

# In C, C++, Java-->complex data type not available

# Format :-
    # a+bj

    # a is real number
    # b is imaginary part
    # j is fixed variable

# For a we can use any base
# For b we should use only decimal form

c = 10 + 20j
print(c)

(10+20j)

c = -10 -25j
print(c)

(-10-25j)

# For a, b we can use both int, float values

c = 10.5 + 20.6j
print(c)

(10.5+20.6j)

c = 0B1111 + 20j
print(c)

(15+20j)

c = 0B1111 + 0b0111j

  Cell In[25], line 1
    c = 0B1111 + 0b0111j
                      ^
SyntaxError: invalid binary literal

a = 10 + 20j
b = 20 + 30j

print(a+b)
print(a-b)
print(a/b)
print(a*b)

(30+50j)
(-10-10j)
(0.6153846153846154+0.0769230769230769j)
(-400+700j)

c = 10*20j      # 10*(0+20j)
print(c)

200j

a = 10 + 20.5j

print(a.real)
print(a.imag)

10.0
20.5

a = True + 20.5j
print(a)

(1+20.5j)

# # # Boolean Data Type :-

# boolean values / logical values

# Example:
    # True --> 1
    # False --> 0

a = True
print(a)

b = False
print(b)

True
False

#  Comparison Operation:
age = 30
if age > 25:
    print('AGE is greater than 25')

AGE is greater than 25

True + True

2

True + False

1

True * False

0

True + Truej

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[48], line 1
----> 1 True + Truej

NameError: name 'Truej' is not defined

True + 20j

(1+20j)

# # # Str Data Type :-

# str --> string

# Any sequence of character within either single quotes or double quotes

s = 'Pulkit'
print(s)

Pulkit

s = "Pulkit"
print(s)

Pulkit

s = Pulkit

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[63], line 1
----> 1 s = Pulkit

NameError: name 'Pulkit' is not defined

s = 'Pulkit"

  Cell In[64], line 1
    s = 'Pulkit"
        ^
SyntaxError: unterminated string literal (detected at line 1)

s = '''Pulkit
    Chahal
    Python
    Practice'''

print(s)

Pulkit
    Chahal
    Python
    Practice

# Multi line String Literals :-

# triple quotes
# triple single quotes
# triple double quotes

s = """Pulkit
    Chahal
    Python
    Practice"""

print(s)

Pulkit
    Chahal
    Python
    Practice

s = "Python classes by 'Durga Sir' are average"
print(s)

Python classes by 'Durga Sir' are average

s = 'Python classes by "Durga Sir" are average'
print(s)

Python classes by "Durga Sir" are average

s = 'Python 'classes' by "Durga Sir" are average'

  Cell In[71], line 1
    s = 'Python 'classes' by "Durga Sir" are average'
                 ^
SyntaxError: invalid syntax

s = '''Python 'classes' by "Durga Sir" are average'''
print(s)

Python 'classes' by "Durga Sir" are average

s1 = '''Pulkit'''
s2 = 'Pulkit'
s3 = "Pulkit"

s1

'Pulkit'

s2

'Pulkit'

s3

'Pulkit'

s = 'Python \'classes\' by "Durga Sir" are average'
print(s)

Python 'classes' by "Durga Sir" are average

s = "Python \'classes\' by \"Durga Sir\" are average"
print(s)

Python 'classes' by "Durga Sir" are average

# We use strings:-

# 1. To define multiline string literals
# 2. To use single quote or double quote as normal character

s = 'durga'

s[0]

'd'

s[1]

'u'

s[2]

'r'

s[10]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[90], line 1
----> 1 s[10]

IndexError: string index out of range

#  +ve index always from left to right
#  -ve index always from right to left

s[-1]

'a'

s[-2]

'g'

s[-3]

'r'

s[-6]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[98], line 1
----> 1 s[-6]

IndexError: string index out of range

s[len(s)-1]

'a'

# # # Slice Operator :-

# peice --> part

# [] to retreive part(slice) of the string

# s[begin:end] -> returns substring from index to end-1 index

s = 'abcdefghijklmnopqrstuvwxyz'

s[5:11] # begin to end-1

'fghijk'

# If we are taking begin, then it will consider from begining of the string i.e default value is : 0

s[:8] # from 0 to 7

'abcdefgh'

# If we are not specifying end index until end of string

s[3:] # from 3 to end of string

'defghijklmnopqrstuvwxyz'

s[:] # from 0 to end of string

'abcdefghijklmnopqrstuvwxyz'

# s and s[:]

s

'abcdefghijklmnopqrstuvwxyz'

s[:]

'abcdefghijklmnopqrstuvwxyz'

# Slice operaator won't raise any IndexError.

# If the index is out of range, then it will consider upto available characters only.

s[0:2689] # from 0 to last

'abcdefghijklmnopqrstuvwxyz'

s[26] # IndexError: string index out of range

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[19], line 1
----> 1 s[26]

IndexError: string index out of range

s[3:5] # from begin index to end-1
        # from 3 to 4

'de'

s1 = 'aabcdefghijklmnopqrstuvwxyz             '

s1[:24656874]

'aabcdefghijklmnopqrstuvwxyz             '

s1[154687:1564687463]

''

s[2:7]

'cdefg'

s[7:2]

''

s[7:4] # from 7 to 3rd index in forward direction

''

# s[begin:end:step]

# Print the given string with first character as uppercase

s = 'durga'
s[0].upper()+s[1:]

'Durga'

# Print the given string with last character as uppercase

s = 'durga'
s[0:-1] + s[-1].upper()
# or
s[0:len(s)-1] + s[-1].upper()

'durgA'

# First and last character capital

s = 'pulkitchahal'
s[0].upper() + s[1:len(s)-1] + s[-1].upper()

'PulkitchahaL'

# # # Mathematical Operator for the String :-

s = 'pulkit' + 'chahal'
s

'durgasoft'

s = '     ' + 'chahal'
s

'     chahal'

s = 'durga' + 10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[52], line 1
----> 1 s = 'durga' + 10

TypeError: can only concatenate str (not "int") to str

s = 10 + 'durga'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[51], line 1
----> 1 s = 10 + 'durga'

TypeError: unsupported operand type(s) for +: 'int' and 'str'

s = '10' + 'durga'
s

'10durga'

s = 'durga' + '10'
s

'durga10'

# If we apply + operator for the strings both arguments should be str type only

# String Repition Operator(* -> Multiplication) ->

s = 'durga' * 5
s

'durgadurgadurgadurgadurga'

s = 5 * 'durga'
s

'durgadurgadurgadurgadurga'

s = 'durga' * 'soft'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[63], line 1
----> 1 s = 'durga' * 'soft'

TypeError: can't multiply sequence by non-int of type 'str'

# int + int
# str + str

# int * str
# str * int

# if we apply * for string one argument should be int

s = 2 * 'ab' * 3
s

'abababababab'

# # # Fundamental data types of Python :-

# int
# float
# complex
# bool
# str

# # # Type Casting :-

# int()
# float()
# complex()
# bool()
# str()

# # 1. int() ->

# We can use this function to convert from other types to int

# int(x)

# We can convert from any type to int type except comlex type.

# If we want to convert str to int type, string should represent only integral value and should be specified only in decimal form(base-10)

int(10.5)

10

int('10')

10

int('10.5')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[77], line 1
----> 1 int('10.5')

ValueError: invalid literal for int() with base 10: '10.5'

int(True)

1

int(10+20j)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[76], line 1
----> 1 int(10+20j)

TypeError: int() argument must be a string, a bytes-like object or a real number, not 'complex'

int('0B1001')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[78], line 1
----> 1 int('0B1001')

ValueError: invalid literal for int() with base 10: '0B1001'

int('durga')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[2], line 1
----> 1 int('durga')

ValueError: invalid literal for int() with base 10: 'durga'

# float --> int   int(10.5)
# complex --> int   int(10+20j)  # Error
# bool --> int  int(True)-->1
# str --> int   int('123')

# # 2. float() :-

# convert from other types to float type

# int --> float     float(10)
# complex --> float    float(10+20j) # Error
# bool --> float      float(True)
# str --> float       float('10')   float('10.5')

# cannot convert complex to float

# str should contains either integral value or floating point value, but compulsory we should use base-10 only

float(0B01010)

10.0

float('0B01010')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[65], line 1
----> 1 float('0B01010')

ValueError: could not convert string to float: '0B01010'

float(10+20j)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[66], line 1
----> 1 float(10+20j)

TypeError: float() argument must be a string or a real number, not 'complex'

float(True)

1.0

float('10')

10.0

float('10.5')

10.5

float(0X01011)

4113.0

float('ten')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[71], line 1
----> 1 float('ten')

ValueError: could not convert string to float: 'ten'

# # 3. complex() :-

# from other types to complex type
# a+bj

# From any type complex is possible

# complex(x), complex(x,y)

# complex(x):
#     x will become real part
#     imaginary part will become 0

# complex(x,y):
#     x will become real part
#     y will become imaginary part

# The second argument can not be string.

# If the first argument is string, then we can not pass second argument.

complex(10)

(10+0j)

complex(10.5)

(10.5+0j)

complex(True)

(1+0j)

complex('10')

(10+0j)

complex('10.5')

(10.5+0j)

complex('10.5j')

10.5j

complex('ten')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[77], line 1
----> 1 complex('ten')

ValueError: complex() arg is a malformed string

complex(10,5)

(10+5j)

complex(10.5,2.5)

(10.5+2.5j)

complex(True,False)

(1+0j)

complex('10','20')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[38], line 1
----> 1 complex('10','20')

TypeError: complex() can't take second arg if first is a string

complex(10,'20')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[39], line 1
----> 1 complex(10,'20')

TypeError: complex() second arg can't be a string

complex('10',20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[40], line 1
----> 1 complex('10',20)

TypeError: complex() can't take second arg if first is a string

complex(10,True)

(10+1j)

complex(10.5,False)

(10.5+0j)

complex(True, 10.5)

(1+10.5j)

complex('10',True)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[8], line 1
----> 1 complex('10',True)

TypeError: complex() can't take second arg if first is a string

complex(0B0111, 0X10134)

(7+65844j)

# # 4. bool() :-

# From other types to bool

# int --> bool        zero means False and non-zero means True
#         bool(0) ==> False
#         bool(1) ==> True
#         bool(2) ==> True

# float --> bool        zero means False and non-zero means True
#         bool(0.0) ==> False
#         bool(0.0001) ==> True

# complex --> bool        If both real and imaginary parts are zero then it is False otherwise it is True
#         bool(0+0j) ==> False
#         bool(0+0.1j) ==> True

# str --> bool        If string is empty then False else True
#         bool('True') ==> True
#         bool('False') ==> True
#         bool('Yes') ==> True
#         bool('No') ==> True
#         bool('') ==> False

bool(0)

False

bool(1)

True

bool(2)

True

bool(-2)

True

bool(0.0)

False

bool(0.0001)

True

bool(0+0j)

False

bool(0+0.1j)

True

bool('True')

True

bool(' ')

True

bool('')

False

bool('False')

True

# # 5. str() :-

# can convert any type to str

str(10)

'10'

str(10.5)

'10.5'

str(10+20j)

'(10+20j)'

str(True)

'True'

str(0B01111)

'15'

# # # Fundamental Data Types Vs Immutability :-

# All Fundamental Data Types are immutable

# In Python everything is treated as object only

# Immutable ==> we cannot change

# Once we creates an object, we cannot change its content.

# If we are trying to change the content, with those cahnges a new object will be created.

x = 10
y = x

print(id(x))
print(id(y))

140731415577672
140731415577672

y = y+1

print(id(x))
print(id(y))

140731415577672
140731415577704

x = True
print(id(x))

y = False
print(id(y))

140731414104640
140731414104672

x = 10
print(id(x))

x = float(x)
print(id(x))

140731415577672
1348341995856

x = 10
print(id(x))

x = x+1
print(id(x))

140731415577672
140731415577704

# # # Fundamental Data Types :-

# int, float, complex, bool, str

# # # Immutability

# # # Immutability Concept :-

# PVM ==> Intelligent

a = 10
b = 10
c = 10

print(id(a))
print(id(b))
print(id(c))

140709893870664
140709893870664
140709893870664

# With Immutability :-

# 1. Memory utilization will be improved.

# 2. Performace also will be improved.

a = 10.5
b = 10.5

print(id(a))
print(id(b))

print(a is b)

2189640694544
2189669176080
False

a = 10
b = 10

print(id(a))
print(id(b))

print(a is b)

140731415577672
140731415577672
True

a = 256
b = 256

print(id(a))
print(id(b))

print(a is b)

140731415585544
140731415585544
True

a = 257
b = 257

print(id(a))
print(id(b))

print(a is b)

2189662697680
2189669186096
False

a = True
b = True

print(id(a))
print(id(b))

print(a is b)

140731414104640
140731414104640
True

a = 'hi'
b = 'hi'

print(id(a))
print(id(b))

print(a is b)

2189573497072
2189573497072
True

a = 10+20j
b = 10+20j

print(id(a))
print(id(b))

print(a is b)

2189669171984
2189669185744
False

# # Note :- For Previous Python Versions ==> 
#         For two different variables(a, b) id will be same except for float type and complex type.

#   For new Python Versions ==>
#         For two different variables(a, b) id will be same for all type.

# Search for an object is available or not?

# Immutability :-

#     Once we creates an object, we cannot change content of that object.
#     If we are trying to change, with those changes a new object wil be created.

# Till how much value reuse can be done?

# int ==> 0 to 256

l = [10, 20, 30, 40]

print(l)

print(id(l))

l[0] = 7777

print(l)

print(id(l))

[10, 20, 30, 40]
1597873346176
[7777, 20, 30, 40]
1597873346176

# If variavble is saved in stack and object in heap, then ID of v1, v2, v3 etc should be different from object ' HYDERABAD' itself..
# How would we check ID or addreass of variable itself?

# id(v1) --> Address of object pointed by v1
# id(v2)

# # Note :- All Fundamental Data Types are Immutable.
#         ex. int, float, bool, complex, str

l1 = [10, 20, 30, 40]
l2 = l1

print(l1)
print(l2)

l1[0] = 777

print(l1)
print(l2)

l2[1] = 888

print(l1)
print(l2)

print(id(l1))
print(id(l2))

print(l1 is l2)

[10, 20, 30, 40]
[10, 20, 30, 40]
[777, 20, 30, 40]
[777, 20, 30, 40]
[777, 888, 30, 40]
[777, 888, 30, 40]
2189669521536
2189669521536
True

l1 = [10, 20, 30, 40]
l2 = [10, 20, 30, 40]

print(l1)
print(l2)

print(id(l1))
print(id(l2))

print(l1 is l2)

[10, 20, 30, 40]
[10, 20, 30, 40]
2189669519232
2189669540416
False

# # # Collection Related Data Types :-

a = 10
b = 10.5
c = True
d = 'durga'

name = 'durga'
names = ['durga', 'ravi', 'shiva']

# Collection Related Data Types :-

#     list
#     tuple
#     set
#     frozenset
#     dict
#     bytes
#     bytearray
#     range

# [] ==> list
# () ==> tuple
# {} ==> set
# {100:'durga', 200:'ravi'} ==> dict

# # list :-

# If we want to represent a group of values as a single entity where insertoion oreder preserved and duplicates are allowed.

list = [10, 10.5, 'durga', True, 10, 10, 10.5]
list

[10, 10.5, 'durga', True, 10, 10, 10.5]

# Properties of List :-

#     1. Insertion order preserved.

#     2. Duplicates are allowed.

#     3. Heterogeneous objects are alllowed.

#     4. Values should be enclosed within [].

#     5. Index and slice are applicable.

#     6. Growable in nature.

#     7. Mutable

list[0]

10

list[-1]

10.5

list[2:5]

['durga', True, 10]

list[0:9:2]

[10, 'durga', 10, 10.5]

list

[10, 10.5, 'durga', True, 10, 10, 10.5]

list.append('ravi')

list

[10, 10.5, 'durga', True, 10, 10, 10.5, 'ravi']

list.append('shiva')

list

[10, 10.5, 'durga', True, 10, 10, 10.5, 'ravi', 'shiva']

list.remove(10)

list

[10.5, 'durga', True, 10, 10, 10.5, 'ravi', 'shiva']

# # Tuple Data Type :-

# It is exactly same as list except that it is immutable

# Read only version of List ==> Tuple

# Tuple Properties :-

#     1. Insertion Order is preserved.

#     2. Indexing and slicing concepts are applicable.

#     3. Duplicates are allowed.

#     4. Heterogenous Objects are allowed.

#     5. ()

#     6. Immutable

#     7. Not Growable

tuple = (10, 20, 30, 40, 10, 'durga', True, 10.5)
tuple

(10, 20, 30, 40, 10, 'durga', True, 10.5)

tuple[0]

10

tuple[0:5]

(10, 20, 30, 40, 10)

tuple[0:6:2]

(10, 30, 10)

tuple.append(10)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[64], line 1
----> 1 tuple.append(10)

AttributeError: 'tuple' object has no attribute 'append'

tuple.remove(10)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[94], line 1
----> 1 tuple.remove(10)

AttributeError: 'tuple' object has no attribute 'remove'

# If content is not fixed and keep om changing ==> List
# Facebook comment: comment

# If content is fixed and won't change ==> Tuple
# Bank account type: Saving or Current

l = [10, 20, 30, 40]
# more memory

t = (10, 20, 30, 40)
# less memory

# Accessing elements is also very fast in Tuple.

# Performance is more for Tuple.

# # Difference b/w List and Tuple : -

# List :-
#     1. Mutable
#     2. [] (Square Brackets)
#     3. More Memory
#     4. Low Performance
#     5. Content not Fixed
#     6. Growable
#     7. Dynamic in Nature

# Tuple :-
#     1. Unmutable
#     2. () (Round Brackets or Parentheses)
#     3. Less Memory
#     4. More Performance
#     5. Content Fixed
#     6. Not Growable
#     7. Static in Nature

t = () # 0 elements
type(t)

tuple

t = (10) # 1 elements is not tuple untill ',' is not present
type(t)

int

t = (10,)
type(t)

tuple

t = (,)
type(t)

  Cell In[92], line 1
    t = (,)
         ^
SyntaxError: invalid syntax

l = [10]
type(l)

list

l = [,]

  Cell In[27], line 1
    l = [,]
         ^
SyntaxError: invalid syntax

t = 10,20,30,40
type(t)

tuple

# In case of Tuple Parantheses are optional

t = 10
type(t)

int

t = 10,
type(t)

tuple

# # Set Data Type :-

# Properties of Set:-

#     1. Dupicates are not allowed

#     2. Order is not Important

#     3. Indexing and Slicing concepts are not applicable

#     4. Heterogeneous objects are allowed

#     5. Mutable

#     6. Growable

#     7. {}

set = {10,20,-30,'durga','apple',10.5,10,20,10.5,'durga','shyam'}
set

{-30, 10, 10.5, 20, 'apple', 'durga', 'shyam'}

type(set)

set

# Examplpe -->

# sms sending application:
#     sms for unique numbers in any order

for x in set:
    print(x)

-30
10.5
20
apple
shyam
10
durga

set.append(50)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[48], line 1
----> 1 set.append(50)

AttributeError: 'set' object has no attribute 'append'

set.add(50)

set

{-30, 10, 10.5, 20, 50, 'apple', 'durga', 'shyam'}

set.remove('durga')
set

{-30, 10, 10.5, 20, 50, 'apple', 'shyam'}

# Difference b/w List and Set :-

# List :-
#     1. Duplicates Allowed
#     2. Order preserved
#     3. Indexing and Slicing Concepts are applicable
#     4. []

# Set :-
#     1. Duplicates Not Allowed
#     2. Order not preserved
#     3. Indexing and Slicing Concepts are not applicable 
#     4. {}

# # Note :- How to Create Empty Set

s = {}
print(type(s)) # beacuse dict is most common used

s = set()
print(type(s)) # set
print(len(s)) # 0
print(s) # set()

<class 'dict'>
<class 'set'>
0
set()

# # Frozenset :-

# It is exactly same as set except that it is immutable.

s = {10,20,30,'durga',10.5,True,10,False}
s

{10, 10.5, 20, 30, False, True, 'durga'}

type(s)

set

fs = frozenset(s)
fs

frozenset({10, 10.5, 20, 30, False, True, 'durga'})

type(fs)

frozenset

fs.add(50)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[7], line 1
----> 1 fs.add(50)

AttributeError: 'frozenset' object has no attribute 'add'

fs.remove(10)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[8], line 1
----> 1 fs.remove(10)

AttributeError: 'frozenset' object has no attribute 'remove'

# # dict Data Type :-

# list ==> [10, 20, 30, 40]
# tuple ==> (10, 20, 30, 40)
# set ==> {10, 20, 30, 40}
# frozenset ==> frozenset({10, 20, 30, 40})

# All these data types can hold individual values.
# key-value pairs are
# rollno --> name
# name --> mail id

# dict --> dictionary

# [] --> list
# () --> tuple
# {} --> set
# {} --> dict

d = {100:'durga', 200:'ravi', 300:'shiva'}

print(d)
print(type(d))

{100: 'durga', 200: 'ravi', 300: 'shiva'}
<class 'dict'>

d = {}

print(type(d))

<class 'dict'>

d = {}

print(d)

{}

# d[key] = value

d[100] = 'sunny'
d[200] = 'bunny'
d[300] = 'chinny'

print(d)

{100: 'sunny', 200: 'bunny', 300: 'chinny'}

print(d[100])

sunny

# Properties of dictionary DataType :-

    # 1. Order is not preserved

    # 2. Indexing and Slicing concepts are not applicable

    # 3. For keys and values we can use any data type no restrictions.

    # 4. keys and values can be hetrogeneous

    # 5. duplicate keys are not allowed but values can be duplicate

    # 6. If we are trying to add entry with duplicate key, then old value will be replaced with new value

    # 7. Mutable

d = {100:'ravi', 'durga':200}
print(d)

{100: 'ravi', 'durga': 200}

d = {a:'durga', b:'abhi'}

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[17], line 1
----> 1 d = {a:'durga', b:'abhi'}

NameError: name 'a' is not defined

a = 100
b = 200
d = {a:'durga', b:'abhi'}

print(d)

{100: 'durga', 200: 'abhi'}

d = {100:'durga', 200:'ravi'}

# keys: 100, 200
# values: 'durga', 'rqavi'

d = {100:'ravi', 200:'durga', 100:'durga', 200:'ravi'}

print(d)

{100: 'durga', 200: 'ravi'}

d = {100:'durga'}

print(d)

d[100] = 'ravi'

print(d)

{100: 'durga'}
{100: 'ravi'}

d = {100:['durga', 'ravi', 'shiva']}

print(d)

{100: ['durga', 'ravi', 'shiva']}

d = {100:'abc', '100':'xyz'}

print(d)

{100: 'abc', '100': 'xyz'}

# # Range Data Type :-

# range means sequence of values

# 0 to 9
# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

r = range(10)

print(r)
print(type(r))

range(0, 10)
<class 'range'>

for x in r:
    print(x)

0
1
2
3
4
5
6
7
8
9

# Properties of Range Data Type :-

    # Sequence

    # form-1:
        # range(n) ==> 0 to n-1 values can be represented

    # form-2:
        # range(begin, end) ==> from begin value to end-1

    # form-3:
        # range(begin, end, increment/decrement value) ==> from begin value to end-1 and increment/decrement

    # Indexing and slicing also applicable

    # Immutable

r = range(2,8)
for x in r:
    print(x)

2
3
4
5
6
7

r = range(1,11)
for x in r:
    print(x)

1
2
3
4
5
6
7
8
9
10

r = range(1,11,2)
for x in r:
    print(x)

1
3
5
7
9

r = range(11,1,-2)
for x in r:
    print(x)

11
9
7
5
3

r = range(1,11,3)
for x in r:
    print(x)

1
4
7
10

l = []
r = range(0,101,5)
for x in r:
    l.append(x)
print(l)

[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]

r = range(1,11,-1)
for x in r:
    print(x)

r = range(10)

print(r)
print(r[0])

range(0, 10)
0

print(r[2])

2

print(r[5])

5

print(r[-1])

9

print(r[2:5])

range(2, 5)

print(r[2:8:2])

range(2, 8, 2)

r[1] = 7777

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[74], line 1
----> 1 r[1] = 7777

TypeError: 'range' object does not support item assignment

# # bytes Data Type :-

# If we want tot represent a group of values within the range 0 to 255

# Properties of byte Data Type :-

# 1. Indexing and slicing applicable

# 2. Values should be in range 0 to 255

# 3. Immutable

# 4. b = bytes()

l = [10, 20, 30, 40]

b = bytes(l)

print(type(b))
print(b)

<class 'bytes'>
b'\n\x14\x1e('

l = [10, 20, 30, 40, 256]

b = bytes(l)

print(type(b))
print(b)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[79], line 3
      1 l = [10, 20, 30, 40, 256]
----> 3 b = bytes(l)
      5 print(type(b))
      6 print(b)

ValueError: bytes must be in range(0, 256)

print(b[0])

10

print(b[2])

30

print(b[-1])

40

for x in bytes[1:3]:
    print(x)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[84], line 1
----> 1 for x in bytes[1:3]:
      2     print(x)

TypeError: type 'bytes' is not subscriptable

for x in b[1:3]:
    print(x)

20
30

l = [10, 20, 30, 40]

b = bytes(l)

b[0] = 777

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[86], line 5
      1 l = [10, 20, 30, 40]
      3 b = bytes(l)
----> 5 b[0] = 777

TypeError: 'bytes' object does not support item assignment

# list --> mutable
# tuple --> immutable
# set --> mutable
# frozenset --> immutable
# dict --> mutable
# range --> immutable
# bytes --> immutable
# bytearray --> mutable

# # bytearray Data Type :-

# It is exactly same as bytes except that it is mutable.

l = [10, 20, 30, 40]

b = bytearray(l)

print(type(b))

<class 'bytearray'>

l = [10, 20, 30, 40, 256]

b = bytearray(l)

print(type(b))

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[93], line 3
      1 l = [10, 20, 30, 40, 256]
----> 3 b = bytearray(l)
      5 print(type(b))

ValueError: byte must be in range(0, 256)

l = [10, 20, 30, 40]

b = bytearray(l)

b[0] = 15

for x in b:
    print(x)

15
20
30
40

# # Data Types :-

# int flaot complex bool str
# list tuple
# set frozenset
# dict
# range
# bytes bytearray

# 1. In general bytes and bytearray types can be used to represent binary information like images, video files etc.

# 2. Long data type avaliable in Python2x but not in Python3x long values also can be represented as int type only

# 3. char data type 'a' as str type

# # None Data Type :-

# None means nothing or no value associated.

# If the value is not available, to handle such type of requirements None (null in Java)

# None --> no value associated

# None is also an object in Python

x = None
print(x)
print(id(x))
print(type(x))

None
140731371719440
<class 'NoneType'>

def f1():
    return 10

r = f1()
print(r)

10

def f1():
    print('hello')

r = f1()
print(r)

hello
None

# Only one None value will be created in python

a = None
b = None
c = None
def f1():
    pass
r = f1()

print(a)
print(id(a))
print(type(a))

print(b)
print(id(b))
print(type(b))

print(c)
print(id(c))
print(type(c))

print(r)
print(id(r))
print(type(r))

None
140731371719440
<class 'NoneType'>
None
140731371719440
<class 'NoneType'>
None
140731371719440
<class 'NoneType'>
None
140731371719440
<class 'NoneType'>

# # Escape Characters :-

# The characters associated with some special meaning

# \n --> New Line
# \t --. Horizontal Tab
# \r --> Carriage Return
# \b --> Backspace
# \f --. Form Feed
# \v --> Vertical Tab
# \' --> Single Quote
# \" --> Double Quote
# \\ --> Backslash Symbol
# etc

s = 'durga\tsoft'
print(s)

durga	soft

s = 'durga\nsoft'
print(s)

durga
soft

s = 'durga\rtsoft'
print(s)

tsoft

s = 'durga\bsoft'
print(s)

durgsoft

s = 'durga\fsoft'
print(s)

durga
soft

s = 'durga\vsoft'
print(s)

durga
soft

s = 'durga\'sof\'t'
print(s)

durga'sof't

s = 'durga\"sof\"t'
print(s)

durga"sof"t

s = 'C:\\Python\\Practice'

# # Comments :-

# Single Line Comment:

# This is code
s = 'pulkit' # code output: 'pulkit'

# Multi-Line Comment:
    # There is no special symbol for multiline comments

'''
This is
Multi-Line
Comment
''' # This is Documentation String but not Comment

"""
This is
Multi-Line
Comment
""" # This is Documentation String but not Comment

s = 'pulkit'

# Triple Quotes can be used for:-

    # 1. To define multiline string literals

    # 2. To use ' or " as symbols

    # 3. To define docstring

# # Constants :-

# Constants concept not applicable in Python

# MAX_VALUE = 10 # it is constant doesn't change its value

# max_value = 10

MAX_VALUE = 10
print(type(MAX_VALUE))

<class 'int'>

# set --> unique elements(no duplicates)
        # order is not important

s = {10, 20, 30, 40}
s.add(50)
print(s)

{40, 10, 50, 20, 30}

# unique elements(no duplicates)
# order is not important
# frozenset

s = {10, 20, 30, 40}
fs = frozenset(s)
fs.add(50)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[4], line 7
      5 s = {10, 20, 30, 40}
      6 fs = frozenset(s)
----> 7 fs.add(50)

AttributeError: 'frozenset' object has no attribute 'add'

# bytes and bytearray

# 0 to 255
# bytes --> immutable
# bytearray --> mutable

# images, video files and audio files etc

l = [10, 20, 30, 40]
b = bytes(l)
for x in b:
    print(x)

10
20
30
40

b[0] = 50

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[8], line 1
----> 1 b[0] = 50

TypeError: 'bytes' object does not support item assignment

l = [10, 20, 30, 40]
b = bytearray(l)
for x in b:
    print(x)

10
20
30
40

b[0] = 50

for x in b:
    print(x)

50
20
30
40

print('# this is comment')

# this is comment

# # Operators :-

# Telephone Operator
# Camera Operator

# # Types of Operators:-

    # 1. Arithmetic Operators

    # 2. Relational Operators

    # 3. Logical Operators

    # 4. Bitwise Operators

    # 5. Assignment Operators

    # 6. Special Operators

# 1. Arithmetic Operators :-

# + --> Addition
# - --> Subtraction
# * --> Multiplication
# / --> Division
# % --> Modulo Operator

# // --> Floor Division Operator
# ** --> Exponent Operator or Power Operator

10+2

12

10-2

8

10*2

20

10%2

0

# # Note:-
    # The result of '/' division operator is always float type

    # // result is either int type or float type
        # If both arguments are int type result is int type only
        # If atleast one argument is float type result is float type

10/2

5.0

10//2

5

23/6

3.8333333333333335

23//6

3

1.2//2

0.0

# 1.56 ->

# floor int value ==> 1
# floor float value ==> 1.0
# ceil int value ==> 2
# ceil float value ==> 2.0

10.0/2

5.0

10.0//2

5.0

10/3

3.3333333333333335

10//3

3

10.0/3

3.3333333333333335

10.0//3

3.0

# * --> multiplication
# ** --> exponential or power

10**3   # 10 * 10 * 10

1000

3**3    # 3 * 3 * 3

27

3***3

  Cell In[85], line 1
    3***3
       ^
SyntaxError: invalid syntax

3.0**3

27.0

3**3*2

54

10**-3

0.001

10**2.8

630.957344480193

3//2

1

# + and * :-

# + operator applicable for str type also
# concatenation operator

s = 'durga' + 'soft'
print(s)

durgasoft

'durga' + str(10)

'durga10'

int('durga')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[97], line 1
----> 1 int('durga')

ValueError: invalid literal for int() with base 10: 'durga'

'durga' + 10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[99], line 1
----> 1 'durga' + 10

TypeError: can only concatenate str (not "int") to str

# Problem with Value ValueError

# Problem with Type TypeError

'durga' * 3

'durgadurgadurga'

'durga' * 'durga'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[102], line 1
----> 1 'durga' * 'durga'

TypeError: can't multiply sequence by non-int of type 'str'

'durga' * int('10')

'durgadurgadurgadurgadurgadurgadurgadurgadurgadurga'

# + --> both arguments should be str type or int type
# * --> one arg str and one arg int

'durga' * 10.0

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[109], line 1
----> 1 'durga' * 10.0

TypeError: can't multiply sequence by non-int of type 'float'

10/0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[110], line 1
----> 1 10/0

ZeroDivisionError: division by zero

10.0/0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[111], line 1
----> 1 10.0/0

ZeroDivisionError: float division by zero

'abc' * 0

''

# 2. Relational Operators :-

# <, <=, >, >=

a = 10
b = 20

a < b

True

a <= b

True

a > b

False

a >= b

False

# string values also comparison is bsaed on unicode value/ascii value

# a --> 97
# b --> 98
# c --> 99

# A --> 65
# B --> 66
# C --> 67

a = 'durga'
b = 'ravi'

a < b

True

a <= b

True

a > b

False

a >= b

False

a = 'durga'
b = 'Durga'

a < b

False

a <= b

False

a > b

True

a >= b

True

ord('d')

100

ord('D')

68

ord('a') * ord('b')

9506

ord('a') + ord('b')

195

# from char find ascii value
    # ord()

# from ascii value to char value
    # chr()

# char --> ord()
# ascii --> chr()

chr(99)

'c'

chr(10)

'\n'

chr(72) + chr(99)

'Hc'

# for boolean types

# True --> 1
# Fasle -->

a = True
b = False

a > b

True

a >= b

True

a < b

False

a <= b

False

'durga' < 10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[151], line 1
----> 1 'durga' < 10

TypeError: '<' not supported between instances of 'str' and 'int'

a = True
b = 10

a > b

False

a < b

True

2**2 < 5

True

2**2 > 5

False

'a' > '297'

True

ord('a')

97

ord('2')

50

ord('a') > ord('2')

True

10 < 20

True

10 < 20 < 30

True

10 < 20 < 30 < 40

True

10 < 20 < 30 < 40 > 50

False

# Chaning of Relational Operators:-
    # If all comparison returns True then the result is True.

    # If atleast one comparison returns False then the result is False.

# Equality Operators :-

# ==    and     !=

# always meant for content comparosion

10 == 20

False

10 == 10

True

10.5 == 10

False

10.0 == 10

True

'durga' == 'ravi'

False

'durga' == 10

False

True == False

False

True == 1

True

ord('d')

100

'd' == 100

False

ord('d') == 100

True

# == --> operator for content comparosion
# = --> means assignment

True == 1.0

True

ord('a') == 97

True

# Chaning of Equality Operators:-
    # If all comparison returns True then the result is True.

    # If atleast one comparison returns False then the result is False.

10 == 20 == 30 == 40

False

10 == 10.0 == 10 == 10.0

True

1 == 1.0 == True == 1.0

True

# == operator and is operator

# == operator meant for content comparosion
# is operator meant for reference comparosion(address comparison)

# is operator returns True if both refrences are pointing to the same object address.

l1 = [10, 20, 30, 40]
l2 = [10, 20, 30, 40]

print(id(l1))
print(id(l2))

print(l1 is l2)
print(l1 == l2)

1444155477056
1444155379712
False
True

l1 = [10, 20, 30, 40]
l2 = l1

print(id(l1))
print(id(l2))

print(l1 is l2)
print(l1 == l2)

1444155476352
1444155476352
True
True

# 3. Logical Operators :-

# and
# or
# not

# For boolean Types :-

    # and --> If both arguments are True then only result is True

    # or --> If atleast one argument is True then result is True

    # not --> complement

True and True

True

True and False

False

False and True

False

False and False

False

not True

False

not False

True

True or True

True

True or False

True

False or True

True

False or False

False

# For non-Boolean Types :-

    # zero consider as False
    # non-zero consider as True

    # empty string, set, list, tuple etc considered as False
    # non-empty considered as True

# For non-Boolean Types we are not getting True or False.

# and Operator :-

# x and y ->
    # if x evalutes to True then the result is y

    # if x evalutes to False then the result is x

10 and 20

20

0 and 10

0

'' and 10

''

'as' and 10

10

# or Operator :-

# x or y ->
    # If x evaluates to True then the result is x

    # If x evaluates to False then the result is y

10 or 20

10

0 or 10

10

10 or 0

10

'' or 'durga'

'durga'

'durga' or ''

'soft'

0 or 0

0

not 10

False

not ''

True

not 0

True

not 'durga'

False

# 4. Bitwise Operators :-

# & --> AND
# | --> OR
# ^ --> X-OR
# ~ --> Bitwise Complement Operator
# << --> Left Shift Operator
# >> --> Right Shift Operator

# Applicable only for:-
    # int type and boolean type

10 & 11

10

True & False

False

10.5 & 11.6

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[4], line 1
----> 1 10.5 & 11.6

TypeError: unsupported operand type(s) for &: 'float' and 'float'

# & --> If both bits are 1 then result is 1

# | --> If atleast one bit is 1 then result is 1

# ^ --> If both bits are different then result is 1
        # if both bits are same then result is 0

a = 4  # 4 --> 1 0 0
b = 5  # 5 --> 1 0 1

a & b  #       1 0 0

4

a = 4  # 4 --> 1 0 0
b = 5  # 5 --> 1 0 1

a | b  #       1 0 1

5

a = 4  # 4 --> 1 0 0
b = 5  # 5 --> 1 0 1

a ^ b  #       0 0 1

1

# Bitwise Complement Operator(~) :-

~4

-5

~9

-10

~-5

4

~-20

19

# 32 bits

# The most significant bit(MSB) acts as sign bit
    # 0 means +ve number
    # 1 means -ve number

# positive numbers will be represented directly in the memory

# But negative numbers will be represented indirectly in the memory in 2's complement form

# 2's complement form = 1's complement form+1
# 1's complement form = intrchange 0s and 1s

#  4 = 0000000000.....000000100
# ~4 = 1111111111.....111111011 ==> -5

# Shift Operators :-

# << and >>

# << --> Left Shift
# >> --> Right Shift

# << --> Left Shift :-

# extra cells are always filled with zero

10 << 2

#   10 --> 00000000000....0000000001010
# 10<< -->     000000000....0000000101000

40

4 << 2

#   4 --> 00000000000....0000000000100
# 4<< -->     000000000....0000000010000

16

# >> --> Right Shift :-

# extra cells are always filled with sign bit
    # +ve number zero(0)
    # -ve number one(1)

10 >> 2

#   10 -->   00000000000....0000000001010
# 10>> --> 00000000000000000....000000010

2

4 >> 2

#   4 -->   00000000000....0000000000100
# 4<< --> 00000000000000000....000000001

1

-10 >> 2

#       10       -->      00000000000....0000000001010
# 1's complement -->      11111111111....1111111110101
#                                                    1
# 2's complement -->      11111111111....1111111110110

#      -10       -->      11111111111....1111111110110

#     -10>>      -->    111111111111111....11111111101  # -ve as first value is 1
# 2's complement -->    000000000000000....00000000010
#                                                    1
#                -->    000000000000000....00000000011

# Value is -ve so ans is -3

-3

10 >> -3

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[38], line 1
----> 1 10 >> -3

ValueError: negative shift count

True & True

True

True | True

True

True ^ False

True

False ^ True

True

~True

-2

~False

-1

True >> 2

0

False >> 2

0

True << 2

4

False << 2

0

False << 4

0

False << 4

0

# 5. Assignment Operators :-

# assignment combined with some other operators: compound assignment operator

# +=
# -=
# *=
# /=
# %=
# //=
# **=
# &=
# |=
# ^=
# >>=
# <<=

x = 10
print(x)
x += 20
print(x)

10
30

x = 4
print(x)
x **= 2
print(x)

4
16

x = 4
print(x)
x &= 5
print(x)

4
4

x = 10
print(x)
x++
print(x)

  Cell In[36], line 3
    x++
       ^
SyntaxError: invalid syntax

x = 10
print(x)
++x
print(x)

10
10

x = 10
print(x)
++++x
print(x)

10
10

x = 10
print(x)
--x
print(x)

10
10

x = 10
print(x)
---x
print(x)

10
10

x = 10
print(x)
x =+ x
print(x)

10
10

x = 10
print(x)
x =+ x
print(x)
x = x
print(x)

10
10
10

x = 10
print(x)
x =-- x
print(x)

10
10

x = 10
print(x)
x =--- x
print(x)

10
-10

# # How to handle increment and decrement in python

x = 10
print(x)

x = x+1
print(x)

10
11

x = 10
print(x)

x += 1
print(x)

10
11

x = 10
print(x)

x = x-1
print(x)

10
9

x = 10
print(x)

x -= 1
print(x)

10
9

# Ternary Operator or Conditional Operator :-

# Unary Operators :-

# ~x
# not x

# Binary Operators :-

# a+b
# a*b

# Ternary Operator or Conditional Operator :-

# a,b = 10,20
# x = 30 if a<b else 40
    # x = first value if condition else second value

a,b = 10,20
x = 30 if a<b else 40
print(x)

30

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))

min = a if a < b else b
print('Minimum Value:', min)

Minimum Value: 2

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))
c = int(input('Enter Third Number: '))

min = a if a<b and a<c else b if b<c else c
print('Minimum Value:', min)

Minimum Value: 12

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))
c = int(input('Enter Third Number: '))

min = a if a>b and a>c else b if b>c else c
print('Maximum Value:', min)

Minimum Value: 99

a = int(input('Enter First Number: '))
b = int(input('Enter Second Number: '))

s1 = 'Both Number are Equal'
s2 = 'First Number is greater than Second Number'
s3 = 'First NUmber is less than Second Number'

result = s1 if a==b else s2 if a>b else s3
print(result)

Both Number are Equal

max(10, 20, 50, 90, 30, 500, 450, 160, 420, 390)

500

# 6. Special Operators :-

# Special Operators :-
    # 1. Identity Operator

    # 2. Membership Operator

# 1. Identity Operator

# is
# is not

# Example:
    # r1 is r2 retruns True if both refrences are pointing to the same address
    # r1 is not r2 retruns True if both refrences are not pointing to the same object

a = 10
b = 10

print(id(a))
print(id(b))

print(a is b)
print(a is not b)

140731373110344
140731373110344
True
False

a = 10
b = 20

print(id(a))
print(id(b))

print(a is b)
print(a is not b)

140731373110344
140731373110664
False
True

a = [10,20,30,40]
b = [10,20,30,40]

print(id(a))
print(id(b))

print(a is b)
print(a == b)
print(a is not b)

1772942460224
1772942011136
False
True
True

a = [10,20,30,40]
b = a

print(id(a))
print(id(b))

print(a is b)
print(a == b)
print(a is not b)

1772948496768
1772948496768
True
True
False

# 2. Membership Operator :-

# given object present in the given collection or not

# collection can be --> string, list, tuple, set, dict etc

# obj in collection ==> if obj is member of collection returns True

# not in collection ==> if obj is not member of collection returns True

x = 'hello learning python is very easy!!!'

'h' in x

True

'd' in x

False

'd' not in x

True

'python' in x

True

'python' not in x

False

list = ['sunny', 'bunny', 'chinny', 'vinny']

'bunny' in list

True

'buuny' in list

False

10+20*3

70

# Python Operator Precedence :-

# ()
# **
# ~,-(unary minus)
# *, /, %, //
# +, -
# <<, >>
# &
# ^
# |
# >, >=, <, <=, ++, !=
# =, +=, -=, *=, ...
# is, is not
# in, in not
# not
# and
# or

a = 30
b = 20
c = 10
d = 5

(a+b)*c/d

100.0

(a+b)*(c/d)

100.0

a+(b*c)/d

70.0

# # # Mathematical Functions by using Math Module :-

# Library Contains ---> a group of packages

# Package Contains ---> a group of modules

# Module Contains ---> a group of functions, variables, classes etc

# Module name: durgamath
    # import durgamath

# short alias name

# import durgamath as dm

# from durgamath as dm
# print(dm.PI)
# print(dm.name)
# dm.add(10,20)
# dm.multiply(10,20)
# s = dm.Student()
# s.activity()

# # Note :-
    # Once we defined alias name, we cannot use original name.

# from durgamath as dm
# print(durgamath.PI)
# print(dm.name)
# dm.add(10,20)
# dm.multiply(10,20)
# s = dm.Student()
# s.activity()

# It will show error

# Access memebers directly without module name???

# from durgamath import PI

# from durgamath import PI, name
# print(PI)
# print(name)
# add(10,20)
# multiply(10,20)
# s = Student()
# s.activity()

# In this only PI and name are available

# from durgamath import *
# print(PI)
# print(name)
# add(10,20)
# multiply(10,20)
# s = Student()
# s.activity()

# Alias name for the members :-

# from durgamath import add as a
# a(100,200)

import math

math.sqrt(16)

4.0

math.pi

3.141592653589793

from math import *

sqrt(16)

4.0

pi

3.141592653589793

import math as m

m.sqrt(16)

4.0

m.pi

3.141592653589793

import math

print(dir(math))

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

from math import *

print('PI =',pi)
print('E =',e)
print(ceil(10.1))
print(floor(10.1))

PI = 3.141592653589793
E = 2.718281828459045
11
10

from random import randint

randint(0,9)

5

randint(0,9)

2

from random import *

randint(0,9)

3

# # Input and Output Statements :-

# Input Statements :-

# To read dynamic input from the keyboard :-
    # 1. raw_input()

    # 2. input()

# 1. raw_input() :-

# x = raw_input('Enter some value:')
# print(type(x)) # str type only
# i = int(x)
# Typecasting is required

# 2. input() :-

# x = input('Enter some value:')
# print(type(x)) # the result need not be str type
# Typecasting is not required

# This story is not appl only for Python-2 but not for Python-3

# In Python-3, we have only input() function but not raw_input() function.

# Python-3 input() function ==> Python-2 raw_input() function

# In Python-3 input() function always returns str type only.
# We have to perform typcasting.

# 100 objects ==> minimum 90% of objects are string type only
# 10% requirement ==> typecasting functions are there

x = input('Enter some value: ')
print(type(x))

<class 'str'>

x = int(input('Enter some value: '))
print(type(x))

<class 'int'>

# # String to Other Types :-

# Type casting functions are required

# Type casting ==> Type Conversion

# str --> int type      ==> int(str)
# str --> float type    ==> float(str)
# str --> boolean type  ==> boolean(str)
# str --> complex type  ==> complex(str)

x = input('Enter some value: ')
i = int(x)
print(type(i))

<class 'int'>

x = input('Enter some value: ')
i = float(x)
print(type(i))

<class 'float'>

x = input('Enter some value: ')
i = bool(x)
print(type(i))

<class 'bool'>

x = input('Enter some value: ')
i = complex(x)
print(type(i))

<class 'complex'>

x = input('Enter First Number: ')
y = input('Enter Second Number: ')

x = int(x)
y = int(y)

print('Sum is:', x+y)

Sum is: 6924

x = int(input('Enter First Number: '))
y = int(input('Enter Second Number: '))

print('Sum is:', x+y)

Sum is: 11

eno = int(input('Enter Employee Number: '))
ename = input('Enter Employee Name: ')
esal = float(input('Enter Employee Salary: '))
eaddr = input('Enter Employee Address: ')
married = bool(input('Employee Married?[True|False]: '))

print('Please Confirm your Information:')
print('Employee Number: ', eno)
print('Employee Name: ', ename)
print('Employee Salary: ', esal)
print('Employee Address: ', eaddr)
print('Employee Married: ', married)

Please Confirm your Information:
Employee Number:  784
Employee Name:  ankd
Employee Salary:  4654.0
Employee Address:  acef
Employee Married:  True

# eval('str')
# eval('10')    --> int
# eval('10.5')  --> float
# eval('True')  --> boolean
# eval('False') --> boolean

eno = int(input('Enter Employee Number: '))
ename = input('Enter Employee Name: ')
esal = float(input('Enter Employee Salary: '))
eaddr = input('Enter Employee Address: ')
married = eval(input('Employee Married?[True|False]: '))

print('Please Confirm your Information:')
print('Employee Number: ', eno)
print('Employee Name: ', ename)
print('Employee Salary: ', esal)
print('Employee Address: ', eaddr)
print('Employee Married: ', married)

Please Confirm your Information:
Employee Number:  46
Employee Name:  dwf
Employee Salary:  45.0
Employee Address:  ad
Employee Married:  False

# # eval() :-

# eval() functin take string as argument and evaluates the result.

x = eval('10+20+30')
print(x)
print(type(x))

60
<class 'int'>

x = int('10+20+30')
print(x)
print(type(x))

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[36], line 1
----> 1 x = int('10+20+30')
      2 print(x)
      3 print(type(x))

ValueError: invalid literal for int() with base 10: '10+20+30'

x = eval(input('Enter some Value:'))
print(x)
print(type(x))

(10, 10, 51)
<class 'tuple'>

x = eval('true')
print(x)
print(type(x))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[38], line 1
----> 1 x = eval('true')
      2 print(x)
      3 print(type(x))

File <string>:1

NameError: name 'true' is not defined

x = eval('True')
print(x)
print(type(x))

True
<class 'bool'>

x = eval(input('Enter some Value:'))
print(x)
print(type(x))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[40], line 1
----> 1 x = eval(input('Enter some Value:'))
      2 print(x)
      3 print(type(x))

File <string>:1

NameError: name 'true' is not defined

# eval() is always taking string argument only, but that string should represent non-string value internally.

x = eval('durga')
print(x)
print(type(x))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[42], line 1
----> 1 x = eval('durga')
      2 print(x)
      3 print(type(x))

File <string>:1

NameError: name 'durga' is not defined

x = eval('10')
print(x)
print(type(x))

10
<class 'int'>

# How to read multiple values from the keyboard in a single line :-

# '10 20 30' ==> a single string which contains int values with space separator

# ['10', '20', '30'] ==> list

s = '10 20 30'

l = s.split()
print(l)

['10', '20', '30']

# string values to int type ==> int()

s = '10 20 30'

l = s.split()
print(l)

['10', '20', '30']

a, b, c = [10, 20, 30]  # unpacking

print(a, b, c)

10 20 30

s = input('Enter two Numbers:')
print(s)

l = s.split()
print(l)

45 65
['45', '65']

l = input('Enter two Numbers:').split()
print(l)

['65', '46']

a, b = input('Enter two Numbers:').split()
print(a)
print(b)

print(type(a))
print(type(b))

46
654
<class 'str'>
<class 'str'>

# for each string present in this list, convert into int value

# list comprehension

a, b = [int(x) for x in input('Enter two Numbers:').split()]

print(a)
print(b)

print(type(a))
print(type(b))

6546
656
<class 'int'>
<class 'int'>

a, b = [int(x) for x in input('Enter two Numbers:').split()]

print('Product of two numbers:', a*b)

Product of two numbers: 3936

a, b = [int(x) for x in input('Enter two Numbers:').split(',')]

print('Product of two numbers:', a*b)

Product of two numbers: 1080

a, b, c = [float(x) for x in input('Enter two Numbers:').split('-')]

print('Sum of Numbers:', a+b+c)

Sum of Numbers: 15.0

# Comand Line Arguments :-

# The arguments which are passing from the command prompt

# cmd line arguments are always str type only

# python test.py    10 20 30

# sys module

# argv --> list
    # contains 4 values
    # test.py 10 20 30

# argv[0] --> test.py
# argv[1] --> 10
# argv[2] --> 20
# argv[3] --> 30

from sys import argv\

print(len(argv))
print(argv)
print(type(argv))

2
['c:\\Users\\pulki\\anaconda3\\envs\\Personal\\Lib\\site-packages\\ipykernel_launcher.py', '--f=c:\\Users\\pulki\\AppData\\Roaming\\jupyter\\runtime\\kernel-v2-15792Rm05Jqyd3e23.json']
<class 'list'>

print(argv[0])

c:\Users\pulki\anaconda3\envs\Personal\Lib\site-packages\ipykernel_launcher.py

for x in argv:
    print(x)

c:\Users\pulki\anaconda3\envs\Personal\Lib\site-packages\ipykernel_launcher.py
--f=c:\Users\pulki\AppData\Roaming\jupyter\runtime\kernel-v2-15792Rm05Jqyd3e23.json

# Input --> python test.py 10 20 30

# from sys import argv

# x = argv[1:]  # ['10', '20', '30']
# sum = 0

# for x1 in x:
    # n = int(x1)
    # sum = sum + n # sum+=n

# print('The Sum:', sum)

# 1. space is the separator
    # we should use ""

# 2. always str type
    # typecasting

# 3. out of range index
    # IndexError

# Language Fundamentals
# Operators and Assignments
# Input and Output Statements
    # Input Statements
        # input()
        # command line arguments

    # Output Statements

# Output Statements :-

# Form-1 :-
    # print()

# To print new line character(\n)

print()

print('Hi')

Hi

print('\n')

# Form-2 :-
    # print('string')

# In the string we can use escape characters also

# String repeation Operator *
    # One argument must be string and other argument must be int
    # 'durga' * 3
    # 3 * 'durga'

# String concatenation Operator also +
    # Both arguments must be strings type:
    # 'durga' + 'soft'

print('DURGA\tSOFTWARE\tSOLUTIONS')

DURGA	SOFTWARE	SOLUTIONS

print('DURGA\nSOFTWARE\nSOLUTIONS')

DURGA
SOFTWARE
SOLUTIONS

print('DURGA' * 3)

DURGADURGADURGA

print('DURGA' + 'SOFT')

DURGASOFT

print(3 + 'durga' + 3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[17], line 1
----> 1 print(3 + 'durga' + 3)

TypeError: unsupported operand type(s) for +: 'int' and 'str'

print(3 * 'DURGA' + 'SOFT')

DURGADURGADURGASOFT

print('DURGA' + 'SOFT')
print('DURGA' , 'SOFT')

DURGASOFT
DURGA SOFT

# Form-3 :-
    # print() with sep attribute

# default value for sep attribute: space

# Other than space if you want any other, then we should use "sep" attribute
    # separator

a,b,c = 10,20,30
print('The Values are:', a,b,c)

The Values are: 10 20 30

name = 'DURGA'
gf = 'SUNNY'
print('Hello', name, 'Your Girl Friend', gf, 'is too good human being')

Hello DURGA Your Girl Friend SUNNY is too good human being

a,b,c = 10,20,30
print(a,b,c, sep='-')

10-20-30

a,b,c = 10,20,30
print(a,b,c, sep='')

102030

# Form-4 :-
    # print() with end attribute

# Other than \n if you want any other character: end attribute

# default value for end attribute: \n

print('Hello')
print('durga')
print('soft')

Hello
durga
soft

print('Hello', end='*')
print('durga', end=' ')
print('soft')

Hello*durga soft

a,b,c = 10,20,30

print(a,b,c, sep='-', end='###')
print(a,b,c, sep='-')
print('durga')

10-20-30###10-20-30
durga

# Form-5 :-
    # print(object)

print(10)

10

print(True)

True

print([10,20,30])

[10, 20, 30]

print((10,20,30))

(10, 20, 30)

# Form-6 :-
    # print(formatted string)

# %i --> int
# %d --> int
# %f --> float
# %s --> string type

# print('formatted string' %(variable list))

a = 10

print('a value is %i' %a)

a value is 10

a = 10
b = 20
c = 30

print('a value is %i b value is %i c value is %i' %(a,b,c))

a value is 10 b value is 20 c value is 30

a = 10
b = 20
c = 30

print('a value is %d b value is %d c value is %d' %(a,b,c))

a value is 10 b value is 20 c value is 30

name = 'durga'
l = [10,20,30,40]

print('hello %s... The List of items are %s' %(name, l))

hello durga... The List of items are [10, 20, 30, 40]

# Form-7 :-
    # print() with {}

# {} --> Replacement Operator

name = 'Durga'
salary = 10000
gf = 'Sunny'

print(f'Hello {name}, your salary is {salary}, and your Friend is {gf}')

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hello {x}, your salary is {y}, and your Friend is {z}'.format(x=name, y=salary, z=gf))

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hello {0}, your salary is {1}, and your Friend is {2}'.format(name, salary, gf))

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hello {0}, your salary is {1}, and your Friend is {2}'.format(salary, gf, name))

Hello 10000, your salary is Sunny, and your Friend is Durga

print('Hello {}, your salary is {}, and your Friend is {}'.format(name, salary, gf))

Hello Durga, your salary is 10000, and your Friend is Sunny

print('Hi {0} sal is {1}'.format(0='AA', 1=10000))

  Cell In[64], line 1
    print('Hi {0} sal is {1}'.format(0='AA', 1=10000))
                                     ^
SyntaxError: expression cannot contain assignment, perhaps you meant "=="?

# Language Fundamentals
# Operators and Assignments
# Input and Output Statements

# # Flow Control :-

# # Flow Controls Statements :-

    # Conditional Statements or Selection Statements :-
        # if
        # if-else
        # if-elif-else
        # if-elif

    # Iterative Statements (Loops) :-
        # for
        # while

    # Transfer Staements :-
        # break
        # continue

# pass
# del

# 1. Conditional Statements :-

# 1. if :-

# if condition:
    # body

# Indentation is important in Python

# if condition:
    # statement
    # statement
    # statement
# statements
# statements

name = input('Enter Your Name:')

if name == 'durga':
    print('Hello Durga!')
print('How are you')

Hello Durga!
How are you

# 2. if-else :-

# if condition:
    # action-1
# else:
    # action-2

name = input('Enter Your Name:')

if name == 'durga':
    print('Hello Durga!')
else:
    print('Hello Guest!')

print('How are you')

Hello Guest!
How are you

# 3. if-elif-else :-

# if condition-1:
    # action-1
# elif condition-2:
    # action-2
# elif condition-3:
    # action-3
# elif condition-4:
    # action-4
# ....
# else:
    # default Action

brand = input('Enter Your Favourite Brand:')

if brand == 'RC':
    print('RC is a great brand')
elif brand == 'KF':
    print('KF is a great brand')
elif brand == 'KO':
    print('KO is a great brand')
elif brand == 'FO':
    print('FO is a great brand')
else:
    print('I dont know that brand')

I dont know that brand

# 4. if-elif :-

# if condition-1:
    # action-1
# elif condition-2:
    # action-2
# elif condition-3:
    # action-3
# elif condition-4:
    # action-4

brand = input('Enter Your Favourite Brand:')

if brand == 'RC':
    print('RC is a great brand')
elif brand == 'KF':
    print('KF is a great brand')
elif brand == 'KO':
    print('KO is a great brand')
elif brand == 'FO':
    print('FO is a great brand')

print('I don\'t know brand')

I don't know brand

n1 = int(input('Enter First Number: '))
n2 = int(input('Enter Second Number: '))

if n1 > n2:
    print(f'{n1} is greater than {n2}')
else:
    print(f'{n1} is smaller than {n2}')

545 is greater than 54

# 2. Iterative Statements :-

# for loop
# while loop

# 1. for loop :-

    # for every element present in the given sequence, if we want to perform certain activity then we should go for for loop.

# for x in sequence:
    # body

l = [10,20,30,40,50,60]
s = {10,20,30,40,50,60}

for x in l:
    print(x)

10
20
30
40
50
60

x = 'durga'

for ch in x:
    print('The Current Character is:',ch)

The Current Character is: d
The Current Character is: u
The Current Character is: r
The Current Character is: g
The Current Character is: a

s = input('Enter Any String:')
i = 0

for ch in s:
    print('The Character Present at', i, 'index:', ch)
    i += 1

The Character Present at 0 index: 3
The Character Present at 1 index: 4
The Character Present at 2 index: k
The Character Present at 3 index: j
The Character Present at 4 index: b
The Character Present at 5 index: g

for x in range(10):
    print('Hello')

Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello

for x in range(10):
    print(x)

0
1
2
3
4
5
6
7
8
9

for x in range(1, 21):
    if x%2 == 0:
        print(x)

2
4
6
8
10
12
14
16
18
20

for x in range(10, 0, -1):
    print(x)

10
9
8
7
6
5
4
3
2
1

# To print the sum of numbers present in the given list?

l = eval(input('Enter List:'))
print(l)
sum = 0
for x in l:
    sum += x
print('Sum is:', sum)

(10, 10, 20, 30, 40, 50)
Sum is: 160

# while loop :-

    # We don't know the number of iteration in advance, as long as some condition is True, execute body 

# while condition:
    # True

# To print numbers from 1 to 10 by using while loop?

x = 1
while x <= 10:
    print(x)
    x += 1

1
2
3
4
5
6
7
8
9
10

# # Note :-
    # for loop is sequence based

    # while loop is condition based

# To display the sum of first n natural numbers?

n = int(input('Enter n values:'))
sum = 0
i = 1
while i <= n:
    sum += i
    i += 1
print('The sum of First {} Numbers: {}'.format(n, sum))

The sum of First 9 numbers: 45

name = ''
i = 1
while name != 'sunny' and i<=10:
    name = input('Enter Name:')
    print('Enter Name:', name)
    i += 1

Enter Name: 454
Enter Name: SADA
Enter Name: ASDSLAMF
Enter Name: DSFKLER
Enter Name: KVNFA
Enter Name: KNAFSKASF
Enter Name: FAKSNFK
Enter Name: MLSNFL
Enter Name: MCKEANF
Enter Name: sunny

name = ''
i = 1
while name != 'sunny' and i<=10:
    name = input('Enter Name:')
    print('Enter Name:', name)
    i += 1
    if i == 10:
        print('You entered more than 10 times. Exiting...')
        break

print('Thanks for Confirmation')

Enter Name: sfew
Enter Name: wgrw
Enter Name: eg
Enter Name: erwg
Enter Name: wrgrw
Enter Name: g
Enter Name: gtrt
Enter Name: wgw
Enter Name: rg
You entered more than 10 times. Exiting...
Thanks for Confirmation

# name != 'sunny' and i<=10     ===> Returns False then only it will be stopped

# name != 'sunny'   ===> If you enter name as sunny the the result is False
# i<=10     ===> If i value > 10 then it results False

# Infinite Loop :-
# Nested Loop :-
    # Loop inside another loop

for i in range(4):
    for j in range(4):
        print(i, j)

0 0
0 1
0 2
0 3
1 0
1 1
1 2
1 3
2 0
2 1
2 2
2 3
3 0
3 1
3 2
3 3

# read data from the end user as long as he poviding valing input

# while data is invalid:
    # read data from the user

# while True:
    # read data from the user
    # if data is valid:
        # break

while True:
    username = input('Enter User Name:')
    pwd = input('Enter Password:')
    if username == 'durga' and pwd == 'sunny':
        print('Login Successful')
        break
    else:
        print('Invalid Credentials. Please try again.')

Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Invalid Credentials. Please try again.
Login Successful

n = int(input('Enter any Number:'))

for i in range(n):
    print('*', end=' ')

* * * * * 

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(n):
        print('*', end=' ')
    print()

* * * 
* * * 
* * * 

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(n):
        print(n, end=' ')
    print()

3 3 3 
3 3 3 
3 3 3 

n = int(input('Enter any Number:'))

for i in range(n):
    print('A '*n)

A A A A A A 
A A A A A A 
A A A A A A 
A A A A A A 
A A A A A A 
A A A A A A 

n = int(input('Enter any Number:'))

for i in range(n):
    print((str(i+1) + ' ')* n)

1 1 
2 2 

n = int(input('Enter any Number:'))

for i in range(n): # for every row
    for j in range(n): # for every column in that row
        print(i+1, end=' ')
    print()

1 1 1 1 1 
2 2 2 2 2 
3 3 3 3 3 
4 4 4 4 4 
5 5 5 5 5 

n = int(input('Enter any Number:'))

for i in range(n): # for every row
    for j in range(n): # for every column in that row
        print(i, end=' ')
    print()

0 0 0 0 0 
1 1 1 1 1 
2 2 2 2 2 
3 3 3 3 3 
4 4 4 4 4 

n = int(input('Enter any Number:'))

for i in range(n): # for every row
    for j in range(n): # for every column in that row
        print(chr(65+i), end=' ')
    print()

A A A A A A A A A 
B B B B B B B B B 
C C C C C C C C C 
D D D D D D D D D 
E E E E E E E E E 
F F F F F F F F F 
G G G G G G G G G 
H H H H H H H H H 
I I I I I I I I I 

n = int(input('Enter any Number:'))

for i in range(n): # for every row i = 1,2,3,4,....,n
    for j in range(n):  # j = 1,2,3,4,..,n
        print(j+1, end=' ')
    print()

1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 

n = int(input('Enter any Number:'))

for i in range(1, n+1): # for every row i = 1,2,3,4,....,n
    for j in range(1, n+1):  # j = 1,2,3,4,..,n
        print(j+1, end=' ')
    print()

2 3 4 5 6 
2 3 4 5 6 
2 3 4 5 6 
2 3 4 5 6 
2 3 4 5 6 

n = int(input('Enter any Number:'))

for i in range(1, n+1): # for every row i = 1,2,3,4,....,n
    for j in range(1, n+1):  # j = 1,2,3,4,..,n
        print(j, end=' ')
    print()

1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 
1 2 3 4 5 

n = int(input('Enter any Number:'))

for i in range(n): # for every row i = 1,2,3,4,....,n
    for j in range(n):  # j = 1,2,3,4,..,n
        print(n-j, end=' ')
    print()

5 4 3 2 1 
5 4 3 2 1 
5 4 3 2 1 
5 4 3 2 1 
5 4 3 2 1 

for i in range(10, 1, -1):
    print(i)

10
9
8
7
6
5
4
3
2

n = int(input('Enter any Number:'))

for i in range(n):
    print('*' * (i+1))

*
**
***

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(i+1):
        print('*', end=' ')
    print()

* 
* * 
* * * 

n = int(input('Enter any Number:'))

for i in range(n):
    for j in range(i+1):
        print(n-j, end=' ')
    print()

5 
5 4 
5 4 3 
5 4 3 2 
5 4 3 2 1 

n = int(input('Enter any Number:'))

for i in range(n):
    print(' '*(n-i-1), end='')
    print('* '*(i+1))

    * 
   * * 
  * * * 
 * * * * 
* * * * * 

# Transfer Statements :-

# 1. break
# 2. continue

# pass and del

# 1. break statement :-

# break loop execution based on some condition

for i in range(10):
    print(i)

0
1
2
3
4
5
6
7
8
9

for i in range(10):
    print(i)
    if i == 5:
        print('Loop Execution enough... plz break!!')
        break;

0
1
2
3
4
5
Loop Execution enough... plz break!!

cart = [10,20,30,40,600,50,60]

for items in cart:
    if items > 500:
        print('To place this order, insurance must be required')
        break
    print(items)

10
20
30
40
To place this order, insurance must be required

# 2. continue statement :-

# we can use continue statement to skip current iteration and continue for the next iteration.

for i in range(10):
    if i == 5:
        continue
    print(i)

0
1
2
3
4
6
7
8
9

for i in range(10):
    if i%2 == 0:
        continue
    print(i)

1
3
5
7
9

for i in range(10):
    if i%2 != 0:
        continue
    print(i)

0
2
4
6
8

cart = [10,20,30,40,600,500,60]

for item in cart:
    if item >= 500:
        print('We cannot process this item beacuse of insurance issue:', item)
        continue
    print('Processing item:', item)

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
We cannot process this item beacuse of insurance issue: 600
We cannot process this item beacuse of insurance issue: 500
Processing item: 60

numbers = [10,20,0,5,0,30]

for n in numbers:
    if n == 0:
        print('We cannot divide with 0')
        continue
    print('100/{} = {}'.format(n, 100/n))

100/10 = 10.0
100/20 = 5.0
We cannot divide with 0
100/5 = 20.0
We cannot divide with 0
100/30 = 3.3333333333333335

numbers = [10,20,0,5,0,30]

for n in numbers:
    if n == 0:
        print('We cannot divide with 0')
        continue
    print('100/{a} = {b}'.format(a=n, b=100/n))

100/10 = 10.0
100/20 = 5.0
We cannot divide with 0
100/5 = 20.0
We cannot divide with 0
100/30 = 3.3333333333333335

# if-else
# for-else
# while-else
# try-else-except-finally

# else block :-

# loops with else block :-

    # 1. some times loop will be executed with out break
    # 2. some times loop will be terminated because of break

# inside loop execution if break statement not executed, then only else part will be executed
# else means loop without break

# else is always associated with break
# without break we can use else but not that much meaningful.

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
Processing item: 50

cart = [10,20,30,40,500]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
we cannot place this order

cart = [10,20,30,40,500]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
we cannot place this order

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
Processing item: 50
Congrats!

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        continue
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
Processing item: 50
Congrats!

cart = [10,20,30,40,500]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        continue
    print('Processing item:', item)
else:
    print('Congrats!')

Processing item: 10
Processing item: 20
Processing item: 30
Processing item: 40
we cannot place this order
Congrats!

cart = [10,20,30,40,50]

for item in cart:
    if item > 50:
        print('we cannot place this order')
        break
    print('Processing item:', item)
    for i in range(2):
        if i == 1:
            break
        print(i)
else:
    print('Congrats!')

Processing item: 10
0
Processing item: 20
0
Processing item: 30
0
Processing item: 40
0
Processing item: 50
0
Congrats!

# 1. Selection Statements/Conditional Statements :-
    # if
    # if-else
    # if-elif
    # if-elif-else

# 2. Iteration Statements (Loops) :-
    # for
    # while
    # for-else
    # while-else
    # else will be executed if there is no break statement

# 3. Transfer Statements :-
    # break
    # continue

# # pass and del :-

# pass :-

# it is a keyword in python

# it is empty statement
# it is null statement
# it won't do anything

if 10>20:
    print('Hello')
else:

  Cell In[10], line 3
    else:
         ^
SyntaxError: incomplete input

if 10>20:
    print('Hello')
else:
    pass

class Loan:
    pass

class GoldLoan(Loan):
    pass

class HomeLoan(Loan):
    pass

class CarLoan(Loan):
    pass

class Loan:
    def getInterestRate(self):
        pass

class GoldLoan(Loan):
    def getInterestRate(self):
        return 10

class HomeLoan(Loan):
    def getInterestRate(self):
        return 7

class CarLoan(Loan):
    def getInterestRate(self):
        return 13

# del :-

s1 = 'durga'
print(s1)

durga

s1 = 'durga'
del s1
print(s1)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[12], line 3
      1 s1 = 'durga'
      2 del s1
----> 3 print(s1)

NameError: name 's1' is not defined

s1 = 'durga'
s1 = None
print(s1)

None

s1 = 'durga'
print(s1)

print(s1[0])

durga
d

del s1[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[18], line 1
----> 1 del s1[0]

TypeError: 'str' object doesn't support item deletion

# pass ===> empty statement
# del ===> to delete variable which are no longer required in our progream automatically the corresponding objects for gc.
        # if useless objects deleted, free memory will be improved our program won't face memory issues.

del 'durga'

  Cell In[21], line 1
    del 'durga'
        ^
SyntaxError: cannot delete literal

s = 'durga'
del s

# # String Data Types :-

s = 'durga'
s = 'ravi'

# either single quotes or double quotes

ch = 'a'

s = '''durga
software
solutions'''
print(s)

durga
software
solutions

# 1. To define multiline string literals.
# 2. To use single o rdouble quotes as symbol only.
# 3. Doc string.

s = '''The classes of 'Python' by "Durga Sir" are good'''
print(s)

The classes of 'Python' by "Durga Sir" are good

s = 'The classes of \'Python\' by \"Durga Sir\" are good'
print(s)

The classes of 'Python' by "Durga Sir" are good

# How to access character of the string :-
    # 1. By using index
    # 2. By using Slice Operator

# 1. By using index :-

# Python supports both +ve and -ve indices :-

# +ve index is always from left to right starts from 0.
# -ve index is always from right to left starts from -1.

s = 'durga'
print(s)
print(s[0])
print(s[1])
print(s[2])
print(s[3])
print(s[4])

durga
d
u
r
g
a

print(s[5])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[20], line 1
----> 1 print(s[5])

IndexError: string index out of range

s = 'durga'
print(s)
print(s[-1])
print(s[-2])
print(s[-3])
print(s[-4])
print(s[-5])

durga
a
g
r
u
d

print(s[-6])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[22], line 1
----> 1 print(s[-6])

IndexError: string index out of range

# Question :-
    # Write a program to read string from the keyboard and display its characters by index wise(both positive index and negative index)?

s = input('Enter String:')
i = 0

for x in s:
    print('The Character Present at', i, 'index:', x)
    i += 1


# Not correct
j = -len(s)
print(j)
for x in s[::-1]:
    print('The Character Present at', j, 'index:', x)
    j += 1

The Character Present at 0 index: a
The Character Present at 1 index: s
The Character Present at 2 index: d
-3
The Character Present at -3 index: d
The Character Present at -2 index: s
The Character Present at -1 index: a

s = input('Enter any String:')
i = 0
for x in s:
    print('The Character Present at Positive Index {} and at Negative Index {} is : {}'. format(i, i-len(s), x))
    i += 1

The Character Present at Positive Index 0 and at Negative Index -3 is : a
The Character Present at Positive Index 1 and at Negative Index -2 is : s
The Character Present at Positive Index 2 and at Negative Index -1 is : d

# 2. By using Slice Operator :-

# s[begin_index:end_index:step]
# s[begin:end:step]

# s[begin_index:end_index]
# from begin_index to end_index

# begin is optional

s = 'Learning Python is very Easy'

s[:]

'Learning Python is very Easy'

s[:7]

'Learnin'

s[1:7]

'earnin'

s[1:7:1]

'earnin'

s[1:7:2]

'eri'

s = 'abcdefghijklmnopqrstuvwxyz'

s[1:15:1]

'bcdefghijklmno'

s[1:15:3]

'behkn'

# for begin and end we can take either positive index or negative index

s[1:10000:1]

'bcdefghijklmnopqrstuvwxyz'

# Slice Operator won't raise index error

s[11100:1000:1]

''

s[-5:-9:-1]

'vuts'

# steps value can be either positive or negative.
# The default step value is: +1.

# +ve step value means forward direction(left to right)
    # from begin to end-1 index

# -ve step value means backward direction(right to left)
    # from end to begin-1 index

s[::1]

'abcdefghijklmnopqrstuvwxyz'

s[::-1]

'zyxwvutsrqponmlkjihgfedcba'

# In Forward Direction:
    # default begin value: 0
    # default end value: len(s)
    # default step value: +1

# In Backward Direction:
    # default begin value: -1
    # default end value: -len(s)+1
    # default step value: -1

s

'abcdefghijklmnopqrstuvwxyz'

s[::-1]

'zyxwvutsrqponmlkjihgfedcba'

len(s)

26

s[-1:-27:-1]

'zyxwvutsrqponmlkjihgfedcba'

# In Forward direction if end value is 0 then result is always empty.

# In Backward direction if end value is -1 then result is always empty.

# s[begin:end:step]
# all attributes are optional
# all values can be either positive or negative

# if step is +ve then forward direction from begin to end-1
# if step is -ve then backward direction from begin to end+1

s = 'abcdefghij'

s[1:6:2]

'bdf'

s[3:7:-1]

''

s[7:4:-1]

'hgf'

s[0:10000:1]

'abcdefghij'

s[1:10000:-1]

''

s[-4:1:-1]

'gfedc'

s[-4:1:-2]

'gec'

s[5:0:1]

''

s[9:0:0]

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[11], line 1
----> 1 s[9:0:0]

ValueError: slice step cannot be zero

s[0:-10:-1]

''

s[-1:-1:-1]

''

s[0:-2:1]

'abcdefgh'

s[1:7:3]

'be'

s[7:1:-3]

'he'

s = input('Enter any string')
print('In Forward direction')
i= 0
while i< len(s):
    print(s[i])
    i+=1

print('In Backward direction')
i = -1
while i > -len(s)-1:
    print(s[i])
    i -= 1

In Forward direction
4
5
6
In Backward direction
6
5
4

# Membership Operator :-

# in
# not in

s = 'durga'

'a' in s

True

'b' in s

False

'b' not in s

True

# Number to Word Conversion :-

s = int(input('Enter the number:'))
s = s%26
num = 65 + s
word = chr(num)
print(word)

M

# Comparison of Strings :-

# >, >=, <=, <, ==

s1 = input('Enter First String:')
s2 = input('Enter Second String:')

if s1 == s2:
    print('Both Strings are equal.')
elif s1 > s2:
    print('First String is greater than Second String.')
else:
    print('First String is smaller than Second String.')

Both Strings are equal.

city = input('Enter City:')

if city == 'Hyderabad':
    print('Hello Hyderabadi...Aadaab')
elif city == 'Chennai':
    print('Hello Madrasi...Vanakkam')
elif city == 'Bangalore':
    print('Hello Kannadiga...Namaskaran')
else:
    print('I am not familiar with', city)

I am not familiar with 456

# Remove Spaces From the Strings :-

# # Remove Spaces From the Strings :-

# rstrip ---> To remove spaces at right hand side(end of the string)
# lstrip ---> To remove spaces from left hand side(beginning of the string)
# strip ---> To remove both sides

# but it will not work on spaces b/w the words
    # ex. it will not work on 'Hydera    bad'

city = input('Enter City:').strip()

if city == 'Hyderabad':
    print('Hello Hyderabadi...Aadaab')
elif city == 'Chennai':
    print('Hello Madrasi...Vanakkam')
elif city == 'Bangalore':
    print('Hello Kannadiga...Namaskaran')
else:
    print('I am not familiar with', city)

Hello Hyderabadi...Aadaab

city = input('Enter City:').strip().lower()

if city == 'hyderabad':
    print('Hello Hyderabadi...Aadaab')
elif city == 'chennai':
    print('Hello Madrasi...Vanakkam')
elif city == 'bangalore':
    print('Hello Kannadiga...Namaskaran')
else:
    print('I am not familiar with', city)

I am not familiar with ghdshas

# Finding Substrings :-

# # Finding Substrings :-

    # find()
    # index()

    # rfind()
    # rindex()

# string.find(substring)
    # Returns index of first occurrence of the given substring
    # Returns -1 if it is not available

# find() will search complete string until finding the first occurrence in forward direction

s = 'Learning Python is very Python easy study Python'
s.find('Python')

9

s.find('Java')

-1

# Membership Operator :- (in and not in)
    # provide True and False
# in ===> True

s.find('r')

3

s.rfind('Python')

42

# find(substring)

# find(substring, begin, end)
    # from begin to end-1

s.find('Python', 1, 6)

-1

s.find('Python', 1, 26)

9

s = 'Learning python is very easy'

s.find('p')

9

len(s)

28

s = 'abc'
len(s)

3

s = 'Learning python is very easy'
s.rfind('y')

27

# index() :-

    # index() method is exactly same as find() method except that if the specified substring is not available then we will get ValueError.

s.find('p')

9

s.index('p')

9

s.find('pt')

-1

s.index('pt')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[14], line 1
----> 1 s.index('pt')

ValueError: substring not found

# Program to display all positions of the substring in the given main string?

s = input('Enter the String:')
subs = input('Character to Find in String:')
print('String:', s)
print('Character:', subs)

count = 0
for i in s:
    if i == subs:
        count += 1

print(count)

String asafasdf
Character a
3

s = input('Enter Main String:')
subs = input('Enter Sub String:')

print('Main String:', s)
print('Sub String:', subs)

n = len(s)
pos = 0
count = 0

while True:
    i = s.find(subs, pos, n)
    if i == -1:
        print('The Total Number of Times Sub String Found:', count)
        break
    else:
        print('Found at index:', i)
        count += 1
        pos = i + len(subs)
        i = s.find(subs, pos, n)

Main String: asdfghjkasdfasdfgasasas
Sub String: a
Found at index: 0
Found at index: 8
Found at index: 12
Found at index: 17
Found at index: 19
Found at index: 21
The Total Number of Times Sub String Found: 6

# Counting Sub-String in the Given String :-

# count() method

# s.count(substring)
# s.count(substring, begin, end)

s = input('Enter Main String:')
subs = input('Enter Sub String:')
print('The Total Number of Times Sub String Found:', s.count(subs))
print('The Total Number of Times Sub String Found:', s.count(subs, 4, 10))

The Total Number of Times Sub String Found: 5
The Total Number of Times Sub String Found: 0

# Replacing a String with Another String :-

# ab ---> xy

# s.replace('ab', 'xy')

s = 'Learning Python is very difficult'

s1 = s.replace('difficult', 'easy')
s1

'Learning Python is very easy'

# Write a script to remove spaces in the given string?
# strip() ---> begining and end of the string but not middle blank spaces

s = 'ab a b aba b a bab'
s1 = s.replace(' ', '')
s1

'abababababab'

s = 'ab a b aba b a bab'
s1 = s.replace(' ', '')

print(len(s)-len(s1))

6

s = 'ab a b aba b a bab'
s

'ab a b aba b a bab'

s1 = s.replace(' ', '')
s1

'abababababab'

s

'ab a b aba b a bab'

# Splitting of Strings :-

# s.split(separator)

s = 'durga software solutions'
s

'durga software solutions'

l = s.split(' ')
l

['durga', 'software', 'solutions']

for x in l:
    print(x)

durga
software
solutions

s = '01-08-2020'
s

'01-08-2020'

l = s.split('-')
l

['01', '08', '2020']

type(l)

list

for x in l:
    print(x)

01
08
2020

s

'01-08-2020'

s = 'hello'
s

'hello'

s[0] = 'p'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[64], line 1
----> 1 s[0] = 'p'

TypeError: 'str' object does not support item assignment

# Joining of Strings :-

# a group of strings(list or tuple) can be joined by using the the given delimiter.

# l = s.split(separator)

# s = separator.join(group of strings)

l = ['sunny', 'bunny', 'hunny']
l

['sunny', 'bunny', 'hunny']

s = '-'.join(l)
s

'sunny-bunny-hunny'

l

['sunny', 'bunny', 'hunny']

t = ('10','20','30')
t

('10', '20', '30')

s = '-'.join(t)
s

'10-20-30'

s = ''.join(t)
s

'102030'

s = ','.join(t)
s

'10,20,30'

# split() ===> str to list
# join() ===> list/tuple to str

# Changing Case of a String :-

# 1. upper() ---> Every lower case character will be converted into upper case

# 2. lower() ---> Every upper case character will be converted into lower case

# 3. swapcase() ---> lower-->upper and upper-->lower

# 4. title() ---> First character of every word in upper case

# 5. capitalize ---> First word of it in uppercase remaing in lower

s = 'learning PYTHON is very easy'
s

'learning PYTHON is very easy'

s.upper()

'LEARNING PYTHON IS VERY EASY'

s.lower()

'learning python is very easy'

s.swapcase()

'LEARNING python IS VERY EASY'

s.title()

'Learning Python Is Very Easy'

s.capitalize()

'Learning python is very easy'

# To check Type of Characters Present in the Given String :-

# 1. isalnum() ---> a to z, A to Z, 0 to 9

# 2. isalpha() ---> a to z, A to Z

# 3. isdigit() ---> 0 to 9

# 4. islower() ---> If every alphabet is in lower case

# 5. isupper() ---> If every alphabet is in upper case

# 6. istitle() ---> If the string is in title case

# 7. isspace() ---> If the string contains only spaces

'Durga786'.isalnum()

True

'durga786'.isalpha()

False

'DurgA'.isalpha()

True

'123456'.isdigit()

True

'durga'.islower()

True

'DURga'.islower()

False

'durga1234'.islower()

True

'ABC123'.isupper()

True

'ABCd'.isupper()

False

'Learning Python is very easy'.istitle()

False

'Learning Python Is Very Easy'.istitle()

True

'       '.isspace()

True

'a   '.isspace()

False

'        a'.isspace()

False

'Durga 123'.isalnum()

False

'Dur  ga'.isalpha()

False

s = input('Enter ANY Character:')
print(s)
if s.isalnum():
    print('The Character is Alphanumeric.')
    if s.isalpha():
        print('The Character is Alphabet.')
        if s.islower():
            print('The Character is Lowercase.')
        else:
            print('The Character is Uppercase.')
    elif s.isdigit():
        print('It is a digit.')
    else:
        print('It is a Mixed String.')
elif s.isspace():
    print('It is Space Character.')
else:
    print('Non Space Special Character.')

23125safsda
The Character is Alphanumeric.
It is a Mixed String.

# Checking Starting and Ending Part of the String :-

# s.startswith(substring)

# s.endswith(substring)

s = 'learning python is very easy'
s

'learning python is very easy'

s.startswith('l')

True

s.startswith('learning python')

True

s.endswith('learning python')

False

s.endswith('sy')

True

s.endswith('very easy')

True

# # Important programs regarding string concept?

# Q1: Write a program to reverse the given string?

str = input('Enter any String:')
print('String:', str)
reverse_str = ''

for i in str[::-1]:
    reverse_str = reverse_str + i

print('Reversed String:', reverse_str)

String: asd
Reversed String: dsa

str = input('Enter any String:')
print('String:', str)

r = reversed(str)
print(type(r))
print(r)

output = ''.join(r)
print('Reversed String:', output)

String: asdg
<class 'reversed'>
<reversed object at 0x00000106A384AA10>
Reversed String: gdsa

str = input('Enter any String:')
print('String:', str)

i = len(str) - 1
target = ''

while i >= 0:
    target += str[i]
    i -= 1
print('Reversed String:', target)

String: asd
Reversed String: dsa

# Q2: Program to reverse order of words?

str = input('Enter any String:')
print('String:', str)

l = str.split()
print(l)
l1 = []
i = len(l)-1

while i >= 0:
    print(l[i])
    l1.append(l[i])
    i -= 1

print('Reversed List:', l1)
print('Reversed Order of Words:', ' '.join(l1))

String: asad cdv vdfb
['asad', 'cdv', 'vdfb']
vdfb
cdv
asad
Reversed String: ['vdfb', 'cdv', 'asad']
Reversed Order of Words: vdfb cdv asad

str = input('Enter any String:')
print('String:', str)

l = str.split()
print(l)

for i in range(len(l)):
    print(l[i])

String: as cd vf
['as', 'cd', 'vf']
as
cd
vf

str = input('Enter any String:')
print('String:', str)

l = str.split()
print(l)
l1 = []
i = len(l)-1

while i >= 0:
    print(l[i])
    l1.append(l[i])
    i -= 1

print('Reversed List:', l1)
print('Reversed Order of Words:', '-'.join(l1))

String: as df gh
['as', 'df', 'gh']
gh
df
as
Reversed List: ['gh', 'df', 'as']
Reversed Order of Words: gh-df-as

# Q3: Program to reverse internal content of each word?

    # input: one two three
    # output: eno owt eerht

s = 'one two three'
print(s)

l = s.split()
print(l)

l1 = []

for x in l:
    l1.append(x[::-1])

print(l1)
output = ' '.join(l1)
print(output)

one two three
['one', 'two', 'three']
['eno', 'owt', 'eerht']
eno owt eerht

# Q4: Program to print cahracters at odd position and even position for the given string?

s = 'abcdefgh'

even = ''
odd = ''

for i in range(len(s)):
    if i % 2 == 0:
        even += s[i]
    else:
        odd += s[i]

print('Even Position Characters:', even)
print('Odd Position Characters:', odd)

Even Position Characters: aceg
Odd Position Characters: bdfh

s = 'abcdefgh'

print('Character at even position:', s[::2])
print('Character at odd position:', s[1::2])

Character at even position: aceg
Character at odd position: bdfh

s = 'abcdefgh'

print('Character at even Position')
i = 0
while i < len(s):
    print(s[i], end=',')
    i += 2

print('\nCharacter at odd Position')
i = 1
while i < len(s):
    print(s[i], end=',')
    i += 2

Character at even position
a,c,e,g,
Character at odd Position
b,d,f,h,

s = 'abcdefgh'

even = []
odd = []

for i in range(len(s)):
    if i % 2 == 0:
        even.append(s[i])
    else:
        odd.append(s[i])

print('Even Position Characters:', even)
print('Odd Position Characters:', odd)

Even Position Characters: ['a', 'c', 'e', 'g']
Odd Position Characters: ['b', 'd', 'f', 'h']

# Q5: Program to merge characters of 2 strings into a single string by taking characters alternatively?

s1 = 'ravi'
s2 = 'teja'

output = ''
i,j = 0, 0

while i < len(s1) or j < len(s2):
    output = output + s1[i] + s2[j]
    i += 1
    j += 1

print(output)

rtaevjia

s1 = 'ravikarn'
s2 = 'teja'

output = ''
i,j = 0, 0

while i < len(s1) or j < len(s2):
    output = output + s1[i] + s2[j]
    i += 1
    j += 1

print(output)

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[51], line 8
      5 i,j = 0, 0
      7 while i < len(s1) or j < len(s2):
----> 8     output = output + s1[i] + s2[j]
      9     i += 1
     10     j += 1

IndexError: string index out of range

s1 = 'ravikarn'
s2 = 'teja'

output = ''
i,j = 0, 0

while i < len(s1) or j < len(s2):
    if i < len(s1):
        output = output + s1[i]
        i += 1
    if j < len(s2):
        output = output + s2[j]
        j += 1

print(output)

rtaevjiakarn

# Q6: Program to sort characters present in the given string. First alphabet symbols and then numeric values?

    # input: B4A1D3
    # output: ABD134

s = 'B4A1D3'

s1 = s2 = ''

for x in s:
    if x.isalpha():
        s1 = s1 +x
    else:
        s2 = s2 + x

print(s1)
print(s2)

print(sorted(s1))
print(sorted(s2))

output = ''
for x in sorted(s1):
    output = output + x
for x in sorted(s2):
    output = output + x

print(output)

BAD
413
['A', 'B', 'D']
['1', '3', '4']
ABD134

s = 'B4A1D3'

s1 = s2 = ''

for x in s:
    if x.isalpha():
        s1 = s1 +x
    else:
        s2 = s2 + x

print(s1)
print(s2)

print(sorted(s1))
print(sorted(s2))

output = ''.join(sorted(s1) + sorted(s2))

print(output)

BAD
413
['A', 'B', 'D']
['1', '3', '4']
ABD134

# input: a4b3c2
# output: aaaabbbcc

s = 'a4b3c2'
output = ''

for x in s:
    if x.isalpha():
        ch = x
    else:
        output = output + ch*int(x)

print(output)

aaaabbbcc

s = 'ab2cd2e2'
output = ''
ch = ''

for x in s:
    if x.isalpha():
        ch = ch + x
    else:
        output = output + ch*int(x)
        ch = ''

print(output)

ababcdcdee

s = 'ab2cd2e2'
output = ''
num = ''
i = 0

while i < len(s):
    if s[i].isalpha():
        ch = s[i]
    else:
        num = num + s[i]
        if i == len(s)-1:
            output = output + ch*int(num)

        if i+1 < len(s) and s[i+1].isalpha():
            output = output + ch*int(num)
            num = ''
    i = i+1
print(output)

bbddee

s = 'ab10cd2e2'
output = ''
num = ''
str = ''
i = 0

while i < len(s):
    if s[i].isalpha() and s[i+1].isalpha():
        output = output + s[i]
    elif s[i].isalpha():
        ch = s[i]
    else:
        num = num + s[i]
        if i == len(s)-1:
            output = output + ch*int(num)

        if i+1 < len(s) and s[i+1].isalpha():
            output = output + ch*int(num)
            num = ''
    i = i+1
print(output)

abbbbbbbbbbcddee

# input: a4k3b2
# output: aeknbd

ord('a')

97

chr(96)

'`'

s = 'ab24k10ba27'
output = ''
num = ''

for i in range(len(s)):
    if s[i].isalpha():
        ch = s[i]
        output = output + ch

    else:
        num = num + s[i]
        if i == len(s) - 1:
            neword = ord(ch) + int(num)
            if neword >= 123:
                neword = (neword % 123) + 97
            newch = chr(neword)
            output = output + newch

        if i+1< len(s) and s[i+1].isalpha():
            neword = ord(ch) + int(num)
            if neword >= 123:
                neword = (neword % 123) + 97
            newch = chr(neword)
            output = output + newch
            num = ''

print(output)

122
117
124
abzkubab

# Q: Program to remove duplicate characters present in the given string?

s = 'aaaabbbcccddd'
l = []

for i in s:
    if i not in l:
        l.append(i)

print(l)
''.join(l)

['a', 'b', 'c', 'd']

'abcd'

s = input('Enter any String:')
l = []

for i in s:
    if i not in l:
        l.append(i)

print(l)
output = sorted(l)
output = ''.join(output)
output = output.replace(' ', '')
print(output)

['a', 's', 'd', ' ', 'm', 'e', 'j', 'v', 'f', 'n']
adefjmnsv

# Q: Program to find the number of occurrences of each character present in the given string?

d = {}
d ['a'] = 1
d['a'] = d['a']+1
print(d)

{'a': 2}

s = 'abcabcabbcde'
d = {}

for x in s:
    if x not in d:
        d[x] = 1
    else:
        d[x] = d[x] + 1

print(d)

for k,v in d.items():
    print('{} occurs {} times'.format(k, v))

{'a': 3, 'b': 4, 'c': 3, 'd': 1, 'e': 1}
a occurs 3 times
b occurs 4 times
c occurs 3 times
d occurs 1 times
e occurs 1 times

# # Collection Related DataType :-

# List
# Tuple
# Set
# Dictionary

# # List :-

# If we want to present a group of individual objects as a single entity wher insertion order preserved and duplicate objects are allowed, then we should go for list.

# 1. insertion order preserved
# 2. duplicate are allowed
# 3. Heterogeneous objects
# 4. It is dynamic ---> increase/decrease
# 5. mutable
# 6. indexing and slicing concepts are applicable
# 7. []
# 8. +ve and -ve index

# Creation of List Objects :-

# 1. empty list :-

l = []
l

[]

# 2. if we know elements already :-

l = [10,20,30]
l

[10, 20, 30]

# 3. with dynamic input :-

l = eval(input('enter list:'))
print(l)
print(type(l))

[10, 20, 30, 40]
<class 'list'>

l = list(range(1,11,2))
print(l)
print(type(l))

[1, 3, 5, 7, 9]
<class 'list'>

l = list(input('Enter String:'))
print(type(l))
print(l)

<class 'list'>
['a', 'd', 's', 's', 'a', 'f', 'd', 's']

# 4. list() function :-

    # l = list(any other sequence)
    # l = list(range(10))

l = list(range(1,11,3))
print(type(l))
print(l)

<class 'list'>
[1, 4, 7, 10]

l = []
print(type(l))
print(l)

<class 'list'>
[]

l = list([10,20,30,40])
print(type(l))
print(l)

<class 'list'>
[10, 20, 30, 40]

l = list({10,20,30,40})
print(type(l))
print(l)

<class 'list'>
[40, 10, 20, 30]

# 5. string class split() method :-

s = 'Learning Python is very easy'
s

'Learning Python is very easy'

l = s.split()
l

['Learning', 'Python', 'is', 'very', 'easy']

# Accessing Elements of List :-

# by using index
# by using slice operator

# # by using index :-

l = [10,20,30,40]
l

[10, 20, 30, 40]

l[0]

10

l[-1]

40

l[3]

40

l[100]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[39], line 1
----> 1 l[100]

IndexError: list index out of range

# # by using slice operator :-

# l[begin:end:step]

# In Forward direction:
    # beging to end-1

# In Backward direction:
    # begin to end+1

l = [10,20,30,40]
l

[10, 20, 30, 40]

l = list('abcdefghijk')
l

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

#  -11  -10  -9   -8   -7   -6   -5   -4   -3   -2   -1

# ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

#   0    1    2    3    4    5    6    7    8    9    10

l[2:7:2]

['c', 'e', 'g']

l[4::2] # from 4 to end-1 (i.e 10)

['e', 'g', 'i', 'k']

l[8:2:-2] # from 8 to 3

['i', 'g', 'e']

l[4:24642:2]

['e', 'g', 'i', 'k']

# list, tuple, string ---> indexing/slicing possible
# set, dictionary ---> indexing/slicing not possible

# beacuse order is not fixed

# # List vs Mutability :-

l = [10,20,30,40]
l

[10, 20, 30, 40]

id(l)

2831139062592

l[0] = 777
l

[777, 20, 30, 40]

id(l)

2831139062592

# Traversing the Elements of List :-

# # Display all elements of list by using while loop :-

l = [10,20,30,40,50]
i = 0
while i < len(l):
    print(l[i])
    i += 1

10
20
30
40
50

l = [10,20,30,40,50]
for x in l:
    print(x)

10
20
30
40
50

# Display only even numbers :-

l = [0,1,2,3,4,5,6,7,8,9,10]
for x in l:
    if x % 2 == 0:
        print(x)

0
2
4
6
8
10

# To access element on base of index use where loop
# for element base use for loop

l = [10,20,30,40]
i = 0
while i<len(l):
    print('The element present at positive index: {} and negative index: {} is: {}'.format(i, i-len(l), l[i]))
    i += 1

The element present at positive index: 0 and negative index: -4 is: 10
The element present at positive index: 1 and negative index: -3 is: 20
The element present at positive index: 2 and negative index: -2 is: 30
The element present at positive index: 3 and negative index: -1 is: 40

# # # List Data Structure :-

# Important Functions and Methods of List :-

# functions ---> POP Concept(Procedural Oriented Programming)
# methods ---> OOP Concept(Object Oriented Programming)

def f1():
    print('f1 function')

class Test:
    def m1(self):
        print('m1 method')

f1()

f1 function

test = Test()
test.m1()

m1 method

s = 'durga'
print(len(s))
print(s.upper())

5
DURGA

# 1. To get information of List :-

# 1. len() :-
    # to retrun the number of elements present in the list

l = [10,20,30,40]
len(l)

4

# 2. count() :-
    # it returns the number of occurrences of specified element

l = [10,20,30,40,10,30,40,10]
l.count(10)

3

l.count(40)

2

l.count(50)

0

# 3. index() :-
    # it returns the index of the first occurrence of specified element

    # ValueError if the element is not present in the list

    # membership operator: in

l = [10,20,30,40,10,30,40,10]
l.index(10)

0

l.index(40)

3

l.index(50)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[25], line 1
----> 1 l.index(50)

ValueError: 50 is not in list

l = [1,2,3,1,1,1,4]

x = int(input('Enter any Element to Find Index:'))

i = l.index(x)

print('{} element first occurrence index is: {}'.format(x,i))

4 element first occurrence index is: 6

l = [1,2,3,1,1,1,4]

x = int(input('Enter any Element to Find Index:'))

if x in l:
    i = l.index(x)
    print('{} element first occurrence index is: {}'.format(x,i))

else:
    print('{} element is not present in the list'.format(x))

8 element is not present in the list

# 2. Manipulating Elements of List :-

# 1. append() :-

l = []
l.append('A')
l.append('B')
l.append('C')
l

['A', 'B', 'C']

l = []
for i in range(101):
    if i%10 == 0:
        l.append(i)

print(l)

[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# 2. insert() :-
    # To insert element ar specified index position

    # If specified index is smaller than min index, then element will be inserted at beginning.

    # If specified index is greater than max index, then element will be inserted at end.

l = [10,20,30,40,50]
l

[10, 20, 30, 40, 50]

id(l)

3050955359232

l.insert(1,70)
l

[10, 70, 20, 30, 40, 50]

id(l)

3050955359232

# l.insert(1 ,70) ---> 70 will insert at position 1

# l[1] = 70 ---> replace value at 1 with 70

l = [10,20,30,40,50]
l

[10, 20, 30, 40, 50]

l.insert(-10,70)
l

[70, 10, 20, 30, 40, 50]

l.insert(100,80)
l

[70, 10, 20, 30, 40, 50, 80]

# # append() vs insert() :-

# append(element) ---> Element will be added in the last position
# insert(index, element) ---> Element will be added in the specified position

# 3. extend() :-
    # l1.extend(l2)
        # All elements present in l2 will be inserted to l1

l1 = [10,20,30,40,50]
l2 = [60,70,80]

print(l1)
print(l2)

for x in l2:
    l1.append(x)
print(l1)

[10, 20, 30, 40, 50]
[60, 70, 80]
[10, 20, 30, 40, 50, 60, 70, 80]

l1 = [10,20,30,40,50]
l2 = [60,70,80]

print(l1)
print(l2)

l1.extend(l2)
print(l1)

[10, 20, 30, 40, 50]
[60, 70, 80]
[10, 20, 30, 40, 50, 60, 70, 80]

# 4. remover() :-
    # remove(element)
    # only first occurence
    # ValueError if not present

l = [10,20,30,40,10,20,50]
l

[10, 20, 30, 40, 10, 20, 50]

l.remove(10)
l

[20, 30, 40, 10, 20, 50]

l.remove(10)
l

[20, 30, 40, 20, 50]

l.remove(60)
l

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[15], line 1
----> 1 l.remove(60)
      2 l

ValueError: list.remove(x): x not in list

l = [10,10,10,10,20,20,30]
x = int(input('Enter Element tot remove:'))

if x in l:
    l.remove(x)
else:
    print('Specified Element not avaialble')

print(l)

[10, 10, 10, 10, 20, 20]

l = [10,10,10,10,20,20,30]
x = int(input('Enter Element tot remove:'))

while True:
    if x in l:
        l.remove(x)
    else:
        break

print(l)

[10, 10, 10, 10, 30]

# 5. pop() :-
    # by default pop() will delete last element and returns that element.

l = [10,10,10,20,20,30]
print(l.pop())
print(l)

30
[10, 10, 10, 20, 20]

l = [10,10,10,20,20,30]
print(l.pop())
print(l.pop())
print(l.pop())
print(l)

30
20
20
[10, 10, 10]

l.pop()

10

l = [10,10,10,20,20,30]

x = l.pop()

x

30

l = [10,10,10]

print(l.pop())
print(l.pop())
print(l.pop())

print(l)

10
10
10
[]

l = [10,10,10]

print(l.pop())
print(l.pop())
print(l.pop())
print(l.pop())

print(l)

10
10
10

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[17], line 6
      4 print(l.pop())
      5 print(l.pop())
----> 6 print(l.pop())
      8 print(l)

IndexError: pop from empty list

l = [10,10,10]

print(l.pop())
print(l.pop())
print(l.pop())
if len(l) != 0:
    print(l.pop())

print(l)

10
10
10
[]

# pop() ---> last element will be deleted
# pop(index) ---> last element will be

l = [10,10,10,20,20,30]

print(l.pop(1))
print(l.pop(1))
print(l.pop(1))

print(l)

10
10
20
[10, 20, 30]

l = [10,20,30,40]
print(l)
i = 0

while i < len(l):
    print(l.pop(i))
    i += 1

print(l)

[10, 20, 30, 40]
10
30
[20, 40]

l = [10,20,30,40]
print(l)
i = 0
n = len(l)

while i < n:
    print('Current index value:', i)
    print('Current n value:', n)
    print('The removed element:', l.pop(i))
    i += 1

print(l)

[10, 20, 30, 40]
Current index value: 0
Current n value: 4
The removed element: 10
Current index value: 1
Current n value: 4
The removed element: 30
Current index value: 2
Current n value: 4

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[34], line 9
      7     print('Current index value:', i)
      8     print('Current n value:', n)
----> 9     print('The removed element:', l.pop(i))
     11     i += 1
     13 print(l)

IndexError: pop index out of range

l = [10,20,30,40]
print(l)

while len(l) != 0:
    print('The removed element:', l.pop(i))

print(l)

[10, 20, 30, 40]
The removed element: 10
The removed element: 20
The removed element: 30
The removed element: 40
[]

# # remove() vs pop() :-

# remove() :-
    # element based removal
    # ValueError, membership operator

# pop() :-
    # index based removaland by default last element will be deleted
    # IndexError

l = [10,20,30,40]
l

[10, 20, 30, 40]

l.pop()

40

l

[10, 20, 30]

l.remove(30)

l

[10, 20]

l.pop(20)

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[44], line 1
----> 1 l.pop(20)

IndexError: pop index out of range

# pop() ---> last element will be deleted
# pop(index) ---> element will be deleted at specified index

# 6. clear() :-
    # to delete all elements

l = [10,20,30,40]
l

[10, 20, 30, 40]

l.clear()

l

[]

l = [10,20,30,40]

print(l)
print(l.clear())
print(l)

[10, 20, 30, 40]
None
[]

# append()
# insert()
# extend()

# remove()
# pop()
# clear()

# Order Elements of the List :-

# 1. reverse() :-

l = [10,20,30,40]

print(l)
l.reverse()
print(l)

[10, 20, 30, 40]
[40, 30, 20, 10]

# 2. sort() :-
    # For numbers: Ascending order
    # For strings: Alphabetic order (ASCII Based)

l = [10,5,15,0]

print(l)
l.sort()
print(l)

[10, 5, 15, 0]
[0, 5, 10, 15]

l = ['sunny', 'bunny', 'vinny', 'pinny', 'chinny']

print(l)
l.sort()
print(l)

['sunny', 'bunny', 'vinny', 'pinny', 'chinny']
['bunny', 'chinny', 'pinny', 'sunny', 'vinny']

l = ['sunny', 'bunny', 'vinny', 'pinny', 'chinny']

print(l)
print(l.sort())
print(l)

['sunny', 'bunny', 'vinny', 'pinny', 'chinny']
None
['bunny', 'chinny', 'pinny', 'sunny', 'vinny']

l = [10,5,15,0]

print(l)
print(l.sort())
print(l)

[10, 5, 15, 0]
None
[0, 5, 10, 15]

l = ['sunny', 'bunny', 10, 'pinny', 20]

print(l)
print(l.sort())
print(l)

['sunny', 'bunny', 10, 'pinny', 20]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[69], line 4
      1 l = ['sunny', 'bunny', 10, 'pinny', 20]
      3 print(l)
----> 4 print(l.sort())
      5 print(l)

TypeError: '<' not supported between instances of 'int' and 'str'

l = ['sunny', 'bunny', 'vinny', 'pinny', 'chinny']

print(l)
print(l.sort(reverse=True))
print(l)

['sunny', 'bunny', 'vinny', 'pinny', 'chinny']
None
['vinny', 'sunny', 'pinny', 'chinny', 'bunny']

# # reverse() vs reversed() :-

# reverse() :-
    # list specific method and won't return anything
    # applicable only for list

# reversed() :-
    # python's inbuilt function and returns reversed object
    # applicable for any sequence

# l.sort() --->

# l.sort(reverse=True) --->

# l.sort(reverse=False) --->

# Aliasing and Cloning :-

# Aliasing :- creating duplicate reference ---> l1 = l2

# Cloning :- creating duplicate list object --->

# Aliasing :-
    # The process of cretaing duplicate refrence variable
    # l2 = l1

# Cloning :-
    # The Process of creating duplicate object
    # Ways to create Cloning :
        # 1. By using slice operator
        # 2. By using copy() method

# Aliasing :-
    # The process of cretaing duplicate refrence variable
    # l2 = l1

l1 = [10,20,30,40]
l2 = l1

print(l1)
print(id(l1))

print(l2)
print(id(l2))

[10, 20, 30, 40]
1435542163200
[10, 20, 30, 40]
1435542163200

l1[1] = 777

print(l1)
print(l2)

[10, 777, 30, 40]
[10, 777, 30, 40]

l2[2] = 888

print(l1)
print(l2)

[10, 777, 888, 40]
[10, 777, 888, 40]

# Cloning :-
    # The Process of creating duplicate object
    # Ways to create Cloning :
        # 1. By using slice operator
        # 2. By using copy() method

l1 = [10,20,30,40]
l2 = l1[:]

print(l1)
print(id(l1))

print(l2)
print(id(l2))

[10, 20, 30, 40]
2546502628992
[10, 20, 30, 40]
2546502573504

l1[1] = 777

print(l1)
print(l2)

[10, 777, 30, 40]
[10, 20, 30, 40]

l1 = [10,20,30,40]
l2 = l1.copy()

print(l1)
print(id(l1))

print(l2)
print(id(l2))

[10, 20, 30, 40]
2546502668224
[10, 20, 30, 40]
2546502553856

l1[1] = 777

print(l1)
print(l2)

[10, 777, 30, 40]
[10, 20, 30, 40]

l1[2] = 888

print(l1)
print(l2)

[10, 777, 888, 40]
[10, 20, 30, 40]

l2[2] = 999

print(l1)
print(l2)

[10, 777, 888, 40]
[10, 20, 999, 40]

# Mathematical Operators for List Object :-

# + operator

a = [10,20,30]
b = [40,50,60]
c = a + b

print(c)

[10, 20, 30, 40, 50, 60]

a = [10,20,30]
b = [40,50,60]
c = a + 40

print(c)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[21], line 3
      1 a = [10,20,30]
      2 b = [40,50,60]
----> 3 c = a + 40
      5 print(c)

TypeError: can only concatenate list (not "int") to list

a = [10,20,30]
b = [40,50,60]
c = a + [40]

print(c)

[10, 20, 30, 40]

# + operator and extend()

# + operator :-
    # both should be list

    # list+list

    # new object will be created and returns that object

# extend() :-
    # one should be list and other can be anything

    # l1.extend(l2)

    # new object won't be created and to the existing object only elements will be be added

a = [10,20,30] + [40,50,60]
print(c)

[10, 20, 30, 40]

a = [10,20,30]
a.extend({'a', 'b', 'c'})
print(a)

[10, 20, 30, 'a', 'c', 'b']

a = [10,20,30]
b = {'a', 'b', 'c'}

c = a + b
print(c)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[30], line 4
      1 a = [10,20,30]
      2 b = {'a', 'b', 'c'}
----> 4 c = a + b
      5 print(c)

TypeError: can only concatenate list (not "set") to list

# * operator :-

x = [10,20,30]
y = x*3
print(y)

[10, 20, 30, 10, 20, 30, 10, 20, 30]

# equality operators(==, !=) :-
    # l1 and l2

    # l1 == l2 returns True

    # 1. The number of elements
    # 2. The order of elements
    # 3. The content of the elements(including case)

x = ['dog', 'cat', 'rat']
y = ['dog', 'cat', 'rat']
z = ['DOG', 'CAT', 'RAT']

x == y

True

x == z

False

x != z

True

# Comparison Operators :-
    # <, >, <=, >=

    # Comparison is always based on first element if first element is same then go for second element

x = [10,10,5]
y = [10,20,30,40,50,60]

x > y

False

x >= y

False

x < y

True

x <= y

True

x = ['dog', 'cat', 'rat']
y = ['dog', 'cat', 'dog']

x > y

True

x >= y

True

x < y

False

x <= y

True

# Membership Operators :-
    # in, not in

x = ['dog', 'cat', 'rat']

'dog' in x

True

'zebra' in x

False

'zebra' not in x

True

# Nested Lists :-

# List inside List

l = [10,20,[30,40]]
l

[10, 20, [30, 40]]

l[0]

10

l[1]

20

l[2]

[30, 40]

l[2][0]

30

l[2][1]

40

l = [10,[20,[30,[40]]]]
l

[10, [20, [30, [40]]]]

l[1][0]

20

l[1][1]

[30, [40]]

l[1][1][0]

30

l[1][1][1]

[40]

l = [[10,20,30],[40,50,60],[70,80,90]]
print(l)

print('Elements by Row Wise:')
for x in l:
    print(x)

print('Elements by Matrix Style:')
for row in l:
    for element in row:
        print(element, end=' ')
    print()

print('Elements by Matrix Style:')
for i in range(len(l)):
    for j in range(len(l[i])):
        print(l[i][j], end=' ')
    print()

[[10, 20, 30], [40, 50, 60], [70, 80, 90]]
Elements by Row Wise:
[10, 20, 30]
[40, 50, 60]
[70, 80, 90]
Elements by Matrix Style:
10 20 30 
40 50 60 
70 80 90 
Elements by Matrix Style:
10 20 30 
40 50 60 
70 80 90 

# List Comprehension :-

# # List Comprehension :-
    # It is very easy and compact way of creating list objects from iterable object(like list, tuple, set, dictionary, range, etc) based on some condition.

    # l = [ expression for item in sequence ]
    # l = [ x for x in range(15) ]

    # l = [ expression for item in sequence if condition ]
    # l = [ 2*item for item in range(1,11) if item%2 == 0 ]

range(10)

range(0, 10)

l = [x for x in range(15)]
l

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

l = [item for item in range(10)]
l

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

l = [item*item for item in range(10)]
l

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

l = [2*item for item in range(10)]
l

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

l = [2*item for item in range(1,11)]
l

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

l = [2*item for item in range(1,11) if item%2==0]
l

[4, 8, 12, 16, 20]

l = [item*item*item for item in range(1,20) if item*item*item%2==0]
l

[8, 64, 216, 512, 1000, 1728, 2744, 4096, 5832]

l = [int(x) for x in input('Enter Multiple Values:').split()]
l

[1, 2, 54, 13, 4, 54, 31, 6, 45]

# Create a lsit with squares of first 10 natural numbers

l = []
for x in range(1,11):
    l.append(x*x)
print(l)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

l = [x*x for x in range(1, 11)]
print(l)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

print([x*x for x in range(1, 11)])

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Create a lsit with squares of first 20 even natural numbers

l = []
for x in range(1, 21):
    if x % 2 == 0:
        l.append(x*x)

print(l)

[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]

l = [ x*x for x in range(1, 21) if x*x % 2 == 0 ]
print(l)

[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]

l = [ x**2 for x in range(1, 21) if x**2 % 2 == 0 ]
print(l)

[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]

words = ['Balaiah', 'Nag', 'Venkatesh', 'Chiranjeevi']

l = [ word[0] for word in words]
print(l)

['B', 'N', 'V', 'C']

num1 = [10, 20, 30, 40]
num2 = [30, 40, 50, 60]

# create a list with numbers which are present in num1 but not in num2

num3 = []
for n in num1:
    if n not in num2:
        num3.append(n)

print(num3)

[10, 20]

num1 = [10, 20, 30, 40]
num2 = [30, 40, 50, 60]

# create a list with numbers which are present in num1 but not in num2

num3 = [ x for x in num1 if x not in num2 ]
print(num3)

[10, 20]

num1 = [10, 20, 30, 40]
num2 = [30, 40, 50, 60]

# create a list with common numbers which are present in both lists

num3 = [ x for x in num1 if x in num2 ]
print(num3)

[30, 40]

s = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG'

words = s.split()
print(words)

['THE', 'QUICK', 'BROWN', 'FOX', 'JUMPS', 'OVER', 'THE', 'LAZY', 'DOG']

l = []
for word in words:
    l.append([word, len(word)])
print(l)

[['THE', 3], ['QUICK', 5], ['BROWN', 5], ['FOX', 3], ['JUMPS', 5], ['OVER', 4], ['THE', 3], ['LAZY', 4], ['DOG', 3]]

l = [ [word, len(word)] for word in words]
print(l)

[['THE', 3], ['QUICK', 5], ['BROWN', 5], ['FOX', 3], ['JUMPS', 5], ['OVER', 4], ['THE', 3], ['LAZY', 4], ['DOG', 3]]

s = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG'

l = [ [word, len(word)] for word in s.split()]
print(l)

[['THE', 3], ['QUICK', 5], ['BROWN', 5], ['FOX', 3], ['JUMPS', 5], ['OVER', 4], ['THE', 3], ['LAZY', 4], ['DOG', 3]]

l = [ [word.lower(), len(word)] for word in s.split()]
print(l)

[['the', 3], ['quick', 5], ['brown', 5], ['fox', 3], ['jumps', 5], ['over', 4], ['the', 3], ['lazy', 4], ['dog', 3]]

l = [ [word.capitalize(), len(word)] for word in s.split()]
print(l)

[['The', 3], ['Quick', 5], ['Brown', 5], ['Fox', 3], ['Jumps', 5], ['Over', 4], ['The', 3], ['Lazy', 4], ['Dog', 3]]

l = [ [word.title(), len(word)] for word in s.split()]
print(l)

[['The', 3], ['Quick', 5], ['Brown', 5], ['Fox', 3], ['Jumps', 5], ['Over', 4], ['The', 3], ['Lazy', 4], ['Dog', 3]]

# Program to display unique vowels present in the given word?
# Example-> 'DURGA'

word = input('Enter any word to Search for vowels:')
print(word)
vowels = ['a', 'e', 'i', 'o', 'u']
found = []

for v in vowels:
    if v in word:
        found.append(v)

print('Unique Vowels Present:', found)

adasfasdfaadsa
Unique Vowels Present: ['a']

word = input('Enter any word to Search for vowels:')
print(word)

found = [ v for v in vowels if v in word]

print('Unique Vowels Present:', found)

aeiojaksdkbvadksfa
Unique Vowels Present: ['a', 'e', 'i', 'o']

l =[1,2,3]

l.extend(10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[43], line 1
----> 1 l.extend(10)

TypeError: 'int' object is not iterable

l.extend('durga')
print(l)

[1, 2, 3, 'd', 'u', 'r', 'g', 'a']

# # Tuple Data Structure :-

# 1. It is exactly same as list exvcept thta it is immutable.
    # Once we creates tuple object, we cannot change its content.
    # It is read only version of list.

# 2. Duplicates are allowed

# 3. Order will be preserved

# 4. index and slicing concepts are applicable

# 5. heterogeneous objects area allowed

# 6. ()

# 7. parenthesis are optional
    # single valued tuple ===> , is manadatory

l = [10, 20, 30, 40]
print(l)
l[0] = 777
print(l)

[10, 20, 30, 40]
[777, 20, 30, 40]

t = (10, 20, 30, 40)
print(t)

(10, 20, 30, 40)

t[0] = 777
print(t)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 t[0] = 777
      2 print(t)

TypeError: 'tuple' object does not support item assignment

t = (10, 20, 10, 'durga', '40')
t

(10, 20, 10, 'durga', '40')

t[0]

10

t[1:4]

(20, 10, 'durga')

t = 10,20,30,40
type(t)

tuple

t = 10,
type(t)

tuple

t = (10)
type(t)

int

t = (10,)
type(t)

tuple

t = ()
type(t)

tuple

# list is mutable where as tuple is immutable
    # facebook/ youtube comments section ---> List

# vendor machines ---> The allowed inputs are always fixed ---> tuple
    # Bank Application
        # account_types: Savings, Current ---> tuple

# Deposit machines..... like Notes are fixed(100, 200, 500, 2000)

# list ---> to access element  l[10] ---> 10ns
# tuple ---> to access element  t[10] ---> 6ns

# 100 elements ---> list ---> 100Bytes
# 100 elements ---> tuple ---> 60Bytes

import sys

l = [10, 20, 30, 40, 50, 60, 70, 80, 90]
t = (10, 20, 30, 40, 50, 60, 70, 80, 90)

print(sys.getsizeof(l))
print(sys.getsizeof(t))

136
112

# A sequence of elements
    # order is important
    # duplicates are allowed

# # Tuple Creation :-

t = ()
type(t)

tuple

# list ---> tuple
# set ---> tuple

# By Using tuple() Function :-

l = [10, 20, 30]
print(l)

t = tuple(l)
print(t)

[10, 20, 30]
(10, 20, 30)

r = range(10)
t = tuple(r)
print(t)

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# eval() :-

t = eval(input('Enter tuple Value:'))
print(type(t))
print(t)

<class 'tuple'>
(4164564, 121, 54)

l = eval(input('Enter List Value:'))
print(type(l))
print(l)

<class 'tuple'>
(54, 5415, 5465, 415)

# # Accessing Elements of Tuple :-

# by using index
# by using slice opeartor

t = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
t

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

t[0]

10

t[5]

60

t[1:8:2]

(20, 40, 60, 80)

# Tuple vs Immutable :-

# Tuples are immutable

t = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
t

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

t[0] = 777

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[29], line 1
----> 1 t[0] = 777

TypeError: 'tuple' object does not support item assignment

# Mathematical Operators :-

# +, *, ==, !=, >, >=, <, <=

t1 = (10, 20, 30)
t2 = (40, 50, 60)

print(t1)
print(t2)

(10, 20, 30)
(40, 50, 60)

t3 = t1 + t2
print(t3)

(10, 20, 30, 40, 50, 60)

t4 = t1 * 3
print(t4)

(10, 20, 30, 10, 20, 30, 10, 20, 30)

# Important Functions and method related to Tuple :-

# 1. len()
# 2. count()
# 3. index()

# 4. sorted()
# 5. min()
# 6. max()

t = (10, 20, 30)
len(t)

3

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.count(10)

3

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.index(10)

0

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.index(40)

3

t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
t1.index(52)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[66], line 2
      1 t1 = (10, 20, 30, 40, 50, 60, 10, 40, 10)
----> 2 t1.index(52)

ValueError: tuple.index(x): x not in tuple

l = [0, 20, 5, 15, 10]
l.sort()
print(l)

[0, 5, 10, 15, 20]

t = (0, 20, 5, 15, 10)
t.sort()
print(t)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[51], line 2
      1 t = (0, 20, 5, 15, 10)
----> 2 t.sort()
      3 print(t)

AttributeError: 'tuple' object has no attribute 'sort'

t = (0, 20, 5, 15, 10)
l1 = tuple(sorted(t))
print(l1)

(0, 5, 10, 15, 20)

t = (0, 20, 5, 15, 10)
l1 = tuple(sorted(t, reverse=True))
print(l1)

(20, 15, 10, 5, 0)

t = (0, 20, 5, 15, 10)
print(t)
print(min(t))

(0, 20, 5, 15, 10)
0

t = (0, 20, 5, 15, 10)
print(t)
print(max(t))

(0, 20, 5, 15, 10)
20

# sort() vs sorted() :-

# sort() is list specific method.
    # Applicable only for list
    # It won't create new list and in the existing list only sorting will be happening
    # return type ---> None

# sorted() is general purpose python's inbuilt function.
    # Applicable for any sequence
    # A new lsit object will be created always
    # return type ---> List

l = [0, 20, 5, 15, 10]
print("Before Sorting:", l)
print("Before Sorting Address:", id(l))

l.sort()
print("After Sorting:", l)
print("After Sorting Address:", id(l))

Before Sorting: [0, 20, 5, 15, 10]
Before Sorting Address: 1986209712704
After Sorting: [0, 5, 10, 15, 20]
After Sorting Address: 1986209712704

l = [0, 20, 5, 15, 10]
print("Before Sorting:", l)
print("Before Sorting Address:", id(l))

l1 = sorted(l)
print("After Sorting:", l1)
print("After Sorting Address:", id(l1))

Before Sorting: [0, 20, 5, 15, 10]
Before Sorting Address: 1986209665280
After Sorting: [0, 5, 10, 15, 20]
After Sorting Address: 1986209667392

print(l)

[0, 5, 10, 15, 20]

t1 = (10, 20, 30, 40)
t2 = (10, 20, 30, 40)
t3 = (20, 30, 40, 10)

print(t1)
print(t2)
print(t3)

(10, 20, 30, 40)
(10, 20, 30, 40)
(20, 30, 40, 10)

t1 == t2

True

t1 == t3

False

t1 != t3

True

t1 < t2

False

t1 < t3

True

# Tuple Packing and Unpacking :-

# Tuple Packing :-
    # t = a, b, c, d ===> pack 4 values into a single tuple

# Tuple Unpacking :-
    # a, b, c, d = t ===> unpack 4 values from a tuple t and assign to a, b, c, d

a = 10
b = 20
c = 30
d = 40

t = a, b, c, d
print(t)

(10, 20, 30, 40)

t = (10, 20, 30, 40)
a, b, c, d = t
print(a, b, c, d)

10 20 30 40

t = (10, 20, 30, 40)
a, b, c, d, e = t
print(a, b, c, d, e)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[87], line 2
      1 t = (10, 20, 30, 40)
----> 2 a, b, c, d, e = t
      3 print(a, b, c, d, e)

ValueError: not enough values to unpack (expected 5, got 4)

t = (10, 20, 30, 40)
a, b, c = t
print(a, b, c)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[88], line 2
      1 t = (10, 20, 30, 40)
----> 2 a, b, c = t
      3 print(a, b, c)

ValueError: too many values to unpack (expected 3)

# *c ---> a group of values(tuple)

# **c ---> a group of key-value pairs(dictionary)

t = (10, 20, 30, 40, 50, 60, 70)
a, b, *c = t

print(a)
print(b)
print(c)

10
20
[30, 40, 50, 60, 70]

# *args ---> variable mumber of arguments
# **kwargs ---> variable mumber of keyword arguments

l = [x * x for x in range(1, 6)]
print(type(l))
print(l)

<class 'list'>
[1, 4, 9, 16, 25]

t = (x * x for x in range(1, 6))
print(type(t))
print(t)

<class 'generator'>
<generator object <genexpr> at 0x000001CE735B45F0>

# Difference b/w List and Tuple :-

# # List :-

    # List is
        # [10, 20, 30, 40]

    # 1. Mutable

    # 2. performance wise, memory wise list is not up to the mark

    # 3. comprehension concept --> list

    # 4. packing

    # 5. List object --> non hashable/ unhashable object
        # We cannot use as key in dictionary


# # Tuple :-

    # Tuple is
        # (10, 20, 30, 40)  or   10, 20, 30, 40

    # 1. Immutable

    # 2. performance wise, memory wise tuple is up to the mark

    # 3. comprehension concept --> not applicable

    # 4. packing and unpacking

    # 5. Tuple object --> hashable object
        # We can use as key in dictionary

d = {[10, 20, 30, 40]: "durga"}
print(d)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[102], line 1
----> 1 d = {[10, 20, 30, 40]: "durga"}
      2 print(d)

TypeError: unhashable type: 'list'

d = {(10, 20, 30, 40): "durga"}
print(d)

{(10, 20, 30, 40): 'durga'}

# WAP to take tuple numbers from keyboard and print ist sum and average?

t = eval(input("Enter Tuple Numbers:"))
print(t)

l = len(t)
sum = 0
for n in t:
    sum = sum + n

print("Sum:", sum)
print('Average:',sum/l)

(1321, 63156, 43654, 63465)
Sum: 171596
Average: 42899.0

# List
# Tuple

    # Order will be preserved
    # Duplicates are allowed

# # Set Data Structure :-

# Order is not important
# Duplicates objects are not allowed i.e. we required to hold only unique objects.

# sms message.about duragasoftonline.com courses offer.
# 1 lakh mobile numbers
# duplicates are not allowed ---> we use set

# # Set Properties :-

    # Order is not Preserved.

    # indexing and slicing concepts are not applicable.

    # Duplicates Objects are not allowed.

    # heterogeneous objects are allowed.

    # mutable and growable

    # by using {} we can represent set of elements

    # mathematical operations like union, intersection, difference etc.

s = {10, "durag", 30}
s

{10, 30, 'durag'}

s = {10, "durag", 30, 10, 10, 20}
s

{10, 20, 30, 'durag'}

# Creation of Set Objects :-

# 1. s = {10, 20, 30, 40}

# 2. s = set(any sequence)
    # s = set(list)
    # s = set(range)

# 3. By using eval()

s = {10, 20, 30, 40}
s

{10, 20, 30, 40}

s = {20, 40, 30, 10}
s

{10, 20, 30, 40}

l = [20, 10, 30, 10, 50, 10, 10, 40]
s = set(l)
print(s)

{40, 10, 50, 20, 30}

l = (20, 10, 30, 10, 50, 10, 10, 40)
s = set(l)
print(s)

{40, 10, 50, 20, 30}

s = set(range(10))
print(s)

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

d = {100: "durga", 200: "ravi"}
s = set(d)
print(s)

{200, 100}

s = set('mississippi')
print(s)

{'s', 'i', 'p', 'm'}

s = eval(input('Any set of Elements:'))
print(s)
print(type(s))

{546, 3435, 46, 63463}
<class 'set'>

# # Empty set Objects :-

# s = {} ===> dict but not set

s = {}
type(s)

dict

s = set()
type(s)

set

# Important Methods and Functions related to Set :-

# 1. s.add(x) ---> To add an element to the set

# 2. s.update(x, y, z)
    # To add multiple items to the set
    # x, y, z are not individual objects, must be sequences

s = set()
print(s)

s.add(70)
s.add(50)
s.add(90)
s.add('ram')
s.add(50)

print(s)

set()
{50, 90, 70, 'ram'}

s = set()
s.update(range(1, 6))
print(s)

{1, 2, 3, 4, 5}

s = set()
s.update(range(1, 6), range(6, 11), "durga", "solutions")
print(s)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'r', 'd', 'n', 'l', 's', 'u', 'g', 'a', 'i', 't', 'o'}

s = set()
s.update(10)
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[39], line 2
      1 s = set()
----> 2 s.update(10)
      3 s

TypeError: 'int' object is not iterable

s = set()
s.update('10')
s

{'0', '1'}

# add() vs update() :-

# add() ---> to add single item

# update() ---> to add multiple items from the given sequence

s = set('mississippi')
s

{'i', 'm', 'p', 's'}

s = set()
s.update(10,)
print(s)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[44], line 2
      1 s = set()
----> 2 s.update(10,)
      3 print(s)

TypeError: 'int' object is not iterable

s = set()
s.update((10,))
print(s)

{10}

s = set()
s

set()

s.add(10)
s

{10}

s.add(10, 20, 30)
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[50], line 1
----> 1 s.add(10, 20, 30)
      2 s

TypeError: set.add() takes exactly one argument (3 given)

s.update(10)
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[51], line 1
----> 1 s.update(10)
      2 s

TypeError: 'int' object is not iterable

s.update(range(1, 11), range(11, 20))
s

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}

s.add(range(1, 10))
s

{1,
 10,
 11,
 12,
 13,
 14,
 15,
 16,
 17,
 18,
 19,
 2,
 3,
 4,
 5,
 6,
 7,
 8,
 9,
 range(1, 10)}

# In set every element should be hashable.

# List is not hashable but tuple is hashable

s = set()
s.add([10, 20, 30])
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[57], line 2
      1 s = set()
----> 2 s.add([10, 20, 30])
      3 s

TypeError: unhashable type: 'list'

s = set()
s.add((10, 20, 30))
s

{(10, 20, 30)}

s = set()
s.add(range(0, 9))
s

{range(0, 9)}

s = set()
s.update(range(0, 9))
s

{0, 1, 2, 3, 4, 5, 6, 7, 8}

l = [10,20,30]
print(l)

l.append(40)
print(l)

l.insert(1, 50)
print(l)

[10, 20, 30]
[10, 20, 30, 40]
[10, 50, 20, 30, 40]

s.add(10)
# Internally PVM will store elements of set based on hashing.

# str is hashable type
# int is hashable type

# list is not hashable

s = set()
s.add(10)
s

{10}

s = set()
s.add(10.5)
s

{10.5}

s = set()
s.add("durga")
s

{'durga'}

s = set()
s.add([10, 20, 30])
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[66], line 2
      1 s = set()
----> 2 s.add([10, 20, 30])
      3 s

TypeError: unhashable type: 'list'

s = set()
s.add((10, 20, 30))
s

{(10, 20, 30)}

# If our frequent operation is search then set is the best choice.

# s = set(list) ---> in this we won;t get any error because we are not adding list object directly, we are adding elements present in the list.

# s.update(list) ---> in this we won;t get any error because we are not adding list object directly, we are adding elements present in the list.

# s.add(list) ---> we are getting error becuase we are adding list object directly to the set.

s = set()
s.add([10, 20, 30]) # we are adding list object to the set
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[70], line 2
      1 s = set()
----> 2 s.add([10, 20, 30])
      3 s

TypeError: unhashable type: 'list'

s = set()
s.update([10, 20, 30])  # we are adding elements present in the list to the set
s

{10, 20, 30}

s = set([10, 20, 30])
s

{10, 20, 30}

s = set()
s.update([10, 20, [30, 40]])
s

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[73], line 2
      1 s = set()
----> 2 s.update([10, 20, [30, 40]])
      3 s

TypeError: unhashable type: 'list'

# 3. remove() elements :-

# s.pop() ---> it removes and returns some random element from the set

s = {10, 50, 40, 20, 5, 0, 5}
print(s)

print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())

{0, 50, 20, 5, 40, 10}
0
50
20
5
40

s = {10, 50, 40, 20, 5, 0, 5}
print(s)

print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())

{0, 50, 20, 5, 40, 10}
0
50
20
5
40
10

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[83], line 10
      8 print(s.pop())
      9 print(s.pop())
---> 10 print(s.pop())

KeyError: 'pop from an empty set'

s = {10, 50, 40, 20, 5, 0, 5}
print(s)

print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
if len(s) != 0:
    print(s.pop())

{0, 50, 20, 5, 40, 10}
0
50
20
5
40
10

s = {10, 20, 30, 10, 20, 30, 40, 50, 60, 70, 80, 10, 20, 30, 40, 50}

while len(s) != 0:
    n = s.pop()
    print("Sending SMS to Mobile Number:", n)

Sending SMS to Mobile Number: 70
Sending SMS to Mobile Number: 40
Sending SMS to Mobile Number: 10
Sending SMS to Mobile Number: 80
Sending SMS to Mobile Number: 50
Sending SMS to Mobile Number: 20
Sending SMS to Mobile Number: 60
Sending SMS to Mobile Number: 30

# 4. remove(x) :-
    # It removes the specified element
    # If the specified element is not available then we will get KeyError

s = {10, 20, 30}
s.remove(20)
print(s)

{10, 30}

s = {10, 20, 30}
s.remove(40)
print(s)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[91], line 2
      1 s = {10, 20, 30}
----> 2 s.remove(40)
      3 print(s)

KeyError: 40

s = {10, 20, 30}
if 40 in s:
    s.remove(40)
print(s)

{10, 20, 30}

# 5. s.discard(x) :-
    # It removes the specified element
    # If the specified element is not available then we won't get any Error.

s = {10, 20, 30}
s.discard(40)
print(s)

{10, 20, 30}

s = {10, 20, 30}

s.discard(40)
s.discard(20)
s.discard(90)
s.discard(70)
s.discard(30)

print(s)

{10}

# remove(x) and discard(x) and pop() :-

# 6. s.clear() :-
    # To remove all elements from the set

s = {10, 20, 50, 560, 54, 40, 30}
print(s)

s.clear()
print(s)

{560, 50, 20, 54, 40, 10, 30}
set()

# s1 = s ===> aliasing	    duplicate reference variable creation

# s1 = s.copy() ===> cloning    duplicate set object creation

s = {10, 20, 30}
s1 = s

print(id(s))
print(id(s1))

2551548162144
2551548162144

s = {10, 20, 30}
s1 = s.copy()

print(id(s))
print(id(s1))

2551548164160
2551548159456

# Mathematical Operations on the Set :-

# 1. union()    ---> A | B
# 2. intersection() ---> A & B
# 3. difference()   ---> A - B
# 4. symmetric_difference() ---> A ^ B

s1 = {1, 2, 3}
s2 = {4, 5, 6}

print(s1)
print(s2)

{1, 2, 3}
{4, 5, 6}

s3 = s1 + s2
print(s3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[3], line 1
----> 1 s3 = s1 + s2
      2 print(s3)

TypeError: unsupported operand type(s) for +: 'set' and 'set'

s3 = s1 * s2
print(s3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[4], line 1
----> 1 s3 = s1 * s2
      2 print(s3)

TypeError: unsupported operand type(s) for *: 'set' and 'set'

# 1. union() :-
    # x.union(y) ===> It returns all elements present in both x and y
    # x | y

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.union(y))
print(x | y)

print(y.union(x))
print(y | x)

{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}

# 2. intersection() :-
    # common elements
    # x.intersection(y)
    # x & y

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.intersection(y))
print(x & y)

print(y.intersection(x))
print(y & x)

{40, 30}
{40, 30}
{40, 30}
{40, 30}

# 3. difference() :-
    # x.difference(y)
    # x - y

    # The elements present in x but not in y

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.difference(y))
print(x - y)

print(y.difference(x))
print(y - x)

{10, 20}
{10, 20}
{50, 60}
{50, 60}

# 3. symmetric_difference() :-
    # x.symmetric_difference(y)
    # x ^ y

    # The elements present in either x or y butu not in both

x = {10, 20, 30, 40}
y = {30, 40, 50, 60}

print(x.symmetric_difference(y))
print(x ^ y)

print(y.symmetric_difference(x))
print(y ^ x)

{10, 50, 20, 60}
{10, 50, 20, 60}
{10, 50, 20, 60}
{10, 50, 20, 60}

# Membership Operator :-

# in, not in

x = {10, 20, 30, 40}
print(x)

{40, 10, 20, 30}

print(10 in x)

True

print(50 in x)

False

print(50 not in x)

True

# Comprehension :-

# list ---> applicable
# tuple ---> not applicable
# set ---> applicable

s = {x * x for x in range(1, 6)}
print(type(s))
print(s)

<class 'set'>
{1, 4, 9, 16, 25}

s = {2**x for x in range(1, 6)}
print(type(s))
print(s)

<class 'set'>
{32, 2, 4, 8, 16}

s1 = {10, 20, 30}
s2 = {20, 30, 10}

print(s1 is s2)
print(s1 == s2)

False
True

s1 = {10, 20, 30}
s2 = {10, 20, 30}

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873356064
2947873352704

s1 = {10, 20, 30}
s2 = s1

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

True
True
2947873356064
2947873356064

s1 = {10, 20, 30}
s2 = s1.copy()

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873357408
2947873352704

s1 = [10, 20, 30]
s2 = [10, 20, 30]

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873771776
2947873774592

s1 = (10, 20, 30)
s2 = (10, 20, 30)

print(s1 is s2)
print(s1 == s2)

print(id(s1))
print(id(s2))

False
True
2947873830336
2947873799232

# For set order is not important
# indexing and slicing concepts are not applicable

s = {10, 20, 30}
print(s)

{10, 20, 30}

s[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[16], line 1
----> 1 s[0]

TypeError: 'set' object is not subscriptable

s = [10, 20, 30]
print(id(s))

s = [20, 30, 10]
print(id(s))

2947873665088
2947879642112

# WAP to delete duplicates present in the list?

l = eval(input("Enter a list of values:"))
print(l)

s = set(l)
print(s)

[4646, 64, 546, 46, 464, 46]
{64, 546, 4646, 46, 464}

l = eval(input("Enter a list of values:"))
print(l)

l1 = []
for x in l:
    if x not in l1:
        l1.append(x)

print(l1)

[46, 22, 21, 12, 12, 45, 45, 65, 65, 85, 95, 85, 95]
[46, 22, 21, 12, 45, 65, 85, 95]

# # Dictionary Data Structure :-

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

# keys ---> 100, 200, 300
# values ---> 'durga', 'ravi', 'shiva'

# duplicate keys are not allowed, but values can be duplicated.
    # If we are trying to add key-value pair but key already present, then old value will be replaced with new value.

# order is not applicable and all elements will be inserted based on hash of keys.

# indexing and slicing concepts are not applicable.

# for keys and values we can take heterogeneous objects.

# dict is mutable.

# dict is growable.

d = {100: "durga", "ravi": 200, True: "shiva"}
print(d)

{100: 'durga', 'ravi': 200, True: 'shiva'}

# How to Create Dictionary :-

# If we don't know data :-

d = {}
print(type(d))

# or

d = dict()
print(type(d))

<class 'dict'>
<class 'dict'>

# d[key] = value    ===>
    # The provided key-valule pair will be added to the dict
    # If the dspecified key is already available then old value will be replaced with new value.

# d = {key1:value1, key2:value2, key3:value3}

d = {}
print(d)

d[100] = "durga"
d[200] = "shiva"
d[300] = "ravi"

print(d)

{}
{100: 'durga', 200: 'shiva', 300: 'ravi'}

d[100] = "pavan"
print(d)

{100: 'pavan', 200: 'shiva', 300: 'ravi'}

d = {1, 2, 3 : 'a', 'b', 'c'}

  Cell In[18], line 1
    d = {1, 2, 3 : 'a', 'b', 'c'}
                 ^
SyntaxError: invalid syntax

# Access Data From the Dictionary :-

# By using key we can access the corresponding value.

d = {100: "pavan", 200: "shiva", 300: "ravi"}
print(d)

{100: 'pavan', 200: 'shiva', 300: 'ravi'}

print(d[200])

shiva

print(d[100])

pavan

print(d[500])

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[23], line 1
----> 1 print(d[500])

KeyError: 500

# Using value can we get key?

d = {100: "pavan", 200: "shiva", 300: "ravi"}
print(d)

key = int(input("Enter key to find corresponding value:"))
if key in d:
    print(d[key])
else:
    print("Specified key not available:", key)

{100: 'pavan', 200: 'shiva', 300: 'ravi'}
Specified key not available: 352

d = {100: "pavan", 200: "shiva", 300: "ravi"}
print(d)
print(d[200])

{100: 'pavan', 200: 'shiva', 300: 'ravi'}
shiva

# Quest: WAP to enter name and marks in a dictionary and display information on the screen?

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    if option.lower() == "n":
        break
    elif option.lower() == 'y':
        continue
    else:
        print('Invalid Input to Continue')
        break

print(d)

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Invalid Input to Continue
{'asdadf': '54', 'amsdka': '95', 'safas': '12', 'dsafads': '56'}

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    while True:
        if option.lower() == "n":
            option = "n"
            break
        elif option.lower() == "y":
            option = "y"
            break
        else:
            option = input("Your Entered option is Invalid, Please Choose Correct option [Y|N]:")
    if option == "n":
        break

print(d)

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
{'ram': '95', 'han': '85', 'nksdnf': "52'", 'dsaf': '5654'}

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    while True:
        if option.lower() in ["y", "n"]:
            break
        else:
            option = input(
                "Your Entered option is Invalid, Please Choose Correct option [Y|N]:"
            )
    if option == "n":
        break

print(d)

Student record inserted Successfully
Student record inserted Successfully
{'ad': '54', 'asd': '5'}

d = {}
while True:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

    option = input("Do you want to insert one more student marks[Y|N]:")
    while True:
        if option.lower() not in ["y", "n"]:
            option = input(
                "Your Entered option is Invalid, Please Choose Correct option [Y|N]:"
            )
        else:
            break
    if option == "n":
        break

print(d)
for x in d:
    print("{}\t{}".format(x, d[x]))

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
{'ram': '52', 'shyam': '95', 'barry': '96'}
ram	52
shyam	95
barry	96

d = {}
while len(d) < 5:
    name = input("Enter Student Name:")
    marks = input("Enter Student Marks:")
    d[name] = marks
    print("Student record inserted Successfully")

print(d)
for x in d:
    print("{}\t{}".format(x, d[x]))

Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
Student record inserted Successfully
{'ram': '10', 'shyam': '30', 'ravi': '65', 'harry': '94', 'barry': '82'}
ram	10
shyam	30
ravi	65
harry	94
barry	82

# Update Dictionary :-

# d = {}

# d[key] = value
    # If the specified key is not already available, then key-value will be added.

    # If the specified key is already available, then olde value will be replaced with new value.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

d[400] = "pavan"
print(d)

d[200] = "harry"
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{100: 'durga', 200: 'ravi', 300: 'shiva', 400: 'pavan'}
{100: 'durga', 200: 'harry', 300: 'shiva', 400: 'pavan'}

# Delete Elements from Dictionary :-

# del d[key]
    # If the specified key is available, then total entry will be deleted.

    # If the specified key is not available, then we will get KeyError.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

del d[100]
print(d)

{200: 'ravi', 300: 'shiva'}

del d[400]
print(d)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[16], line 1
----> 1 del d[400]
      2 print(d)

KeyError: 400

if 400 in d:
    del d[400]
print(d)

{200: 'ravi', 300: 'shiva'}

# To remove all the entries :-

    # d.clear()

    # del d

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

d.clear()
print(d)

{}

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

del d
print(d)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[25], line 2
      1 del d
----> 2 print(d)

NameError: name 'd' is not defined

# Important Methods and Functions related to Dictionary :-

# 1. dict() :-

d = dict()
print(d)
print(type(d))

{}
<class 'dict'>

d = dict({100: "ram", 200: "durga"})
print(d)
print(type(d))

{100: 'ram', 200: 'durga'}
<class 'dict'>

# [(100, 'durga'), (200, 'shiva'), (300, 'ravi')]   ---> List of Tuples

d = dict([(100, "durga"), (200, "shiva"), (300, "ravi")])
print(d)
print(type(d))

{100: 'durga', 200: 'shiva', 300: 'ravi'}
<class 'dict'>

d = dict(((100, "durga"), (200, "shiva"), (300, "ravi")))
print(d)
print(type(d))

{100: 'durga', 200: 'shiva', 300: 'ravi'}
<class 'dict'>

d = dict([[100, "durga"], [200, "shiva"], [300, "ravi"]])
print(d)
print(type(d))

{100: 'durga', 200: 'shiva', 300: 'ravi'}
<class 'dict'>

d = dict({[100, "durga"], [200, "shiva"], [300, "ravi"]})
print(d)
print(type(d))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[35], line 1
----> 1 d = dict({[100, "durga"], [200, "shiva"], [300, "ravi"]})
      2 print(d)
      3 print(type(d))

TypeError: unhashable type: 'list'

d = dict({(100, "durga"), (200, "shiva"), (300, "ravi")})
print(d)
print(type(d))

{300: 'ravi', 100: 'durga', 200: 'shiva'}
<class 'dict'>

# 2. len() :-
    # returns the number of items in the dictionary
        # item ---> key-value pair

d = dict({(100, "durga"), (200, "shiva"), (300, "ravi")})
print(d)
print(len(d))

{300: 'ravi', 100: 'durga', 200: 'shiva'}
3

# 3. get(key) :-

    # returns the corresponding value.
    # If specified key not available then None

# d[key]    ---> KeyError

# d.get(key)    ---> None
# d.get(key, default_value)

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.get(100))

durga

print(d.get(200))

ravi

print(d.get(900))

None

print(d.get(900, 'no value'))

no value

# 5. pop() :-

    # d.pop(key)
        # remove item(key-value pair) associated with the specified key and returns the corresponding value.

        # If the specified key not already available then we will get KeyError.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.pop())
print(d)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 print(d.pop())
      2 print(d)

TypeError: pop expected at least 1 argument, got 0

print(d.pop(200))
print(d)

ravi
{100: 'durga', 300: 'shiva'}

print(d.pop(500))
print(d)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[7], line 1
----> 1 print(d.pop(500))
      2 print(d)

KeyError: 500

# 6. popitem() :-

    # d.popitem()
        # It will remove an arbitrary item from the dict and returns it.

        # If the dict is empty then we get KeyError

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.popitem())
print(d)

(300, 'shiva')
{100: 'durga', 200: 'ravi'}

print(d.popitem())
print(d)

(200, 'ravi')
{100: 'durga'}

print(d.popitem())
print(d)

(100, 'durga')
{}

print(d.popitem())
print(d)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[13], line 1
----> 1 print(d.popitem())
      2 print(d)

KeyError: 'popitem(): dictionary is empty'

# 7. keys() :-

    # d.keys()

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1
print(d)

{'A': 100, 'B': 110, 'C': 120, 'D': 130, 'E': 140, 'F': 150, 'G': 160, 'H': 170, 'I': 180, 'J': 190, 'K': 200, 'L': 210, 'M': 220, 'N': 230, 'O': 240, 'P': 250, 'Q': 260, 'R': 270, 'S': 280, 'T': 290, 'U': 300, 'V': 310, 'W': 320, 'X': 330, 'Y': 340, 'Z': 350}

while len(d) != 0:
    print('Processing item:', d.popitem())

Processing item: ('Z', 350)
Processing item: ('Y', 340)
Processing item: ('X', 330)
Processing item: ('W', 320)
Processing item: ('V', 310)
Processing item: ('U', 300)
Processing item: ('T', 290)
Processing item: ('S', 280)
Processing item: ('R', 270)
Processing item: ('Q', 260)
Processing item: ('P', 250)
Processing item: ('O', 240)
Processing item: ('N', 230)
Processing item: ('M', 220)
Processing item: ('L', 210)
Processing item: ('K', 200)
Processing item: ('J', 190)
Processing item: ('I', 180)
Processing item: ('H', 170)
Processing item: ('G', 160)
Processing item: ('F', 150)
Processing item: ('E', 140)
Processing item: ('D', 130)
Processing item: ('C', 120)
Processing item: ('B', 110)
Processing item: ('A', 100)

print(d)

{}

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

k = d.keys()
print(type(k))
print(k)

for k1 in k:
    print(k1)

<class 'dict_keys'>
dict_keys(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'])
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

for k1 in d.keys():
    print(k1)

A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

# 8. values() :-

    # d.values()

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

print(d.values())

dict_values([100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350])

i = 0
d = {}
while i < 26:
    d[chr(65 + i)] = 100 + 10 * i
    i = i + 1

print(d.values())
for v in d.values():
    print(v)

dict_values([100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350])
100
110
120
130
140
150
160
170
180
190
200
210
220
230
240
250
260
270
280
290
300
310
320
330
340
350

d = {100: "durga", 200: "durga", 300: "durga"}
for v in d.values():
    print(v)

durga
durga
durga

# 9. items() :-

    # d.items()
        # item ---> key-value pair

d = {100: "durga", 200: "ravi", 300: "shiva"}

i = d.items()

print(type(i))
print(i)

<class 'dict_items'>
dict_items([(100, 'durga'), (200, 'ravi'), (300, 'shiva')])

d = {100: "durga", 200: "ravi", 300: "shiva"}

for x in d.items():
    print(x)

(100, 'durga')
(200, 'ravi')
(300, 'shiva')

d = {100: "durga", 200: "ravi", 300: "shiva"}

for k in d.keys():
    print("Key:", k)

for v in d.values():
    print("Value:", v)

for k, v in d.items():
    print("{}:{}".format(k, v))

Key: 100
Key: 200
Key: 300
Value: durga
Value: ravi
Value: shiva
100:durga
200:ravi
300:shiva

# 10. setdefault() :-

    # d.setdefault(k, v)
        # If the specified key available, then it returnsthe corresponding value.

        # If the specified key not available, then the provided key-value pair will be added as a new item to the dictionary.

d = {100: "durga", 200: "ravi", 300: "shiva"}
print(d)

{100: 'durga', 200: 'ravi', 300: 'shiva'}

print(d.setdefault(100, "sunny"))
d.setdefault(100, "sunny")

print(d)

durga
{100: 'durga', 200: 'ravi', 300: 'shiva', 500: 'bunny'}

print(d.setdefault(500, "bunny"))
d.setdefault(500, "bunny")

print(d)

bunny
{100: 'durga', 200: 'ravi', 300: 'shiva', 500: 'bunny'}

# 11. update() :-

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = {400: "sunny", 500: "bunny", 600: "harry"}

print(d1)
print(d2)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{400: 'sunny', 500: 'bunny', 600: 'harry'}

d1.update(d2)
print(d1)

{100: 'durga', 200: 'ravi', 300: 'shiva', 400: 'sunny', 500: 'bunny', 600: 'harry'}

print(d2)

{400: 'sunny', 500: 'bunny', 600: 'harry'}

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = {400: "sunny", 500: "bunny", 100: "harry"}

print(d1)
print(d2)

d1.update(d2)
print(d1)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{400: 'sunny', 500: 'bunny', 100: 'harry'}
{100: 'harry', 200: 'ravi', 300: 'shiva', 400: 'sunny', 500: 'bunny'}

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = {400: "sunny", 500: "bunny", 100: "harry"}

print(d1)
print(d2)

d1.update(d2)
d2.update(d1)

print(d1)
print(d2)

{100: 'durga', 200: 'ravi', 300: 'shiva'}
{400: 'sunny', 500: 'bunny', 100: 'harry'}
{100: 'harry', 200: 'ravi', 300: 'shiva', 400: 'sunny', 500: 'bunny'}
{400: 'sunny', 500: 'bunny', 100: 'harry', 200: 'ravi', 300: 'shiva'}

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1.copy()

print(id(d1))
print(id(d2))

1543898304192
1543899138368

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1

print(id(d1))
print(id(d2))

1543892330624
1543892330624

# d2 = d1   ===> duplicate reference variable and aliasing
# d2 = d1.copy()    ===> duplicate object and cloning

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1.copy()

print(id(d1))
print(id(d2))

print(d1 is d2)

1543898481920
1543892379136
False

d1 = {100: "durga", 200: "ravi", 300: "shiva"}
d2 = d1

print(id(d1))
print(id(d2))

print(d1 is d2)

1543898489856
1543898489856
True

# 1. dict()
# 2. len()
# 3. clear()
# 4. get()
    # d.get(key)
    # d.get(key, default_value)
# 5. pop()
# 6. popitem()
# 7. keys()
# 8. values()
# 9. items()
# 10. setdefault()
# 11. update()
# 12. copy()

# d[key] = value
# del d[key]

# Ques: WAP to take dictionary from the keyboard and print the sum of values?

d = eval(input("Enter Dictionary:"))
print(d)
sum(d.values())

print("The Sum:", sum(d.values()))

{'a': 10, 'b': 20, 'v': 50}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[72], line 3
      1 d = eval(input("Enter Dictionary:"))
      2 print(d)
----> 3 sum(d.values())
      5 print("The Sum:", sum(d.values()))

TypeError: 'int' object is not callable

d = eval(input("Enter Dictionary:"))
print(d)
sum = 0
for v in d.values():
    sum = sum + v

print("The Sum:", sum)

The Sum: 60

# Ques: WAP to find the number of occurreneces of each letter present in the given string?

s = input("Enter any word:")
print(s)

d = {}
for ch in s:
    if ch in d:
        d[ch] = d[ch] + 1
    else:
        d[ch] = 1

print(d)

mississippi
{'m': 1, 'i': 4, 's': 4, 'p': 2}

s = input("Enter any word:")
print(s)

d = {}
for ch in s:
    d[ch] = d.get(ch, 0) + 1

print(d)

for k, v in d.items():
    print("{} occurs {} times".format(k, v))

mississippi
{'m': 1, 'i': 4, 's': 4, 'p': 2}
m occurs 1 times
i occurs 4 times
s occurs 4 times
p occurs 2 times

s = input("Enter any word:")
print(s)

d = {}
for ch in s:
    d[ch] = d.get(ch, 0) + 1

print(d)

for k, v in sorted(d.items()):
    print("{} occurs {} times".format(k, v))

mississippi
{'m': 1, 'i': 4, 's': 4, 'p': 2}
i occurs 4 times
m occurs 1 times
p occurs 2 times
s occurs 4 times

s = input("Enter any word:")
print(s)
vowels = {'a','e','i','o','u'}

d = {}
for ch in s:
    if ch in vowels:
        d[ch] = d.get(ch, 0) + 1

print(d)

for k, v in sorted(d.items()):
    print("{} occurs {} times".format(k, v))

missipkdanskbfked vm,asd kjcvvhadsukc shad cadsjvgcjakevld jds
{'i': 2, 'a': 6, 'e': 2, 'u': 1}
a occurs 6 times
e occurs 2 times
i occurs 2 times
u occurs 1 times

# # Merging of Collections :-

l1 = [10, 20, 30]
l2 = [40, 50, 60]

l3 = l1 + l2
print(l3)

[10, 20, 30, 40, 50, 60]

t1 = (10, 20, 30)
t2 = (40, 50, 60)

t3 = t1 + t2
print(t3)

(10, 20, 30, 40, 50, 60)

# List and Tuple ---> Apply
# Set and Dictionary ---> Not Apply

l1 = [10, 20, 30]
l2 = [40, 50, 60]

l3 = [*l1, *l2]
print(l3)

[10, 20, 30, 40, 50, 60]

l1 = (10, 20, 30)
l2 = (40, 50, 60)

l3 = (*l1, *l2)
print(l3)

(10, 20, 30, 40, 50, 60)

s1 = {10, 20, 30}
s2 = {40, 50, 60}

s3 = s1 + s2
print(s3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[9], line 4
      1 s1 = {10, 20, 30}
      2 s2 = {40, 50, 60}
----> 4 s3 = s1 + s2
      5 print(s3)

TypeError: unsupported operand type(s) for +: 'set' and 'set'

s1 = {10, 20, 30}
s2 = {40, 50, 60}

s3 = {*s1, *s2}
print(s3)

{50, 20, 40, 10, 60, 30}

s1 = {10, 20, 30}
s2 = {40, 50, 60}
s = {"A", "B", "C"}

s3 = {*s1, *s2, *s}
print(s3)

{40, 10, 50, 'C', 20, 'A', 'B', 60, 30}

s1 = {10, 20, 30}
s2 = {40, 50, 60}
s = {"A", "B", "C"}

l = [*s1, *s2, *s]
print(l)

[10, 20, 30, 40, 50, 60, 'C', 'B', 'A']

s1 = {10, 20, 30}
s2 = (40, 50, 60)
s = ["A", "B", "C"]

list = [*s1, *s2, *s]
print(list)

[10, 20, 30, 40, 50, 60, 'A', 'B', 'C']

s1 = {10, 20, 30}
s2 = (40, 50, 60)
s = ["A", "B", "C"]

tuple = (*s1, *s2, *s)
print(tuple)

(10, 20, 30, 40, 50, 60, 'A', 'B', 'C')

s1 = {10, 20, 30}
s2 = (40, 50, 60)
s = ["A", "B", "C"]

set = {*s1, *s2, *s}
print(set)

{40, 10, 50, 'C', 20, 'A', 'B', 60, 30}

d1 = {100: "A", 200: "B"}
d2 = {300: "C", 400: "D"}
d3 = {500: "E", 600: "F"}

result = {}
print(result)

{}

result = {**d1, **d2, **d3}
print(result)

{100: 'A', 200: 'B', 300: 'C', 400: 'D', 500: 'E', 600: 'F'}

result = {*d1, *d2, *d3}
print(result)

{400, 100, 500, 200, 600, 300}

result = {*d1.values(), *d2.values(), *d3.values()}
print(result)

{'C', 'D', 'F', 'E', 'B', 'A'}

# # Limitations for + Operator :-

# 1. Applicable only for list, tuple but not for set and dict

# 2. Compulsory both arguments should be same type.

# # Nested Collections :-

# Collection inside Collection
# Django, DRF

# inside list, we can take tuple
# inside dict, we can take another dict

l = [(10, 20, 30), (40, 50, 60)]
print(l)

[(10, 20, 30), (40, 50, 60)]

print(l[0][1])

20

print(l[1][2])

60

d = {
    "cars": ("Innova", "Honda", "BMW"),
    "mobiles": ("Samsung", "Nokia", "Iphone"),
}

print(d["cars"])

('Innova', 'Honda', 'BMW')

print(d["cars"][1])

Honda

print(d.get("cars")[1])

Honda

# To display all mobile names
for mobile in d['mobiles']:
    print(mobile)

Samsung
Nokia
Iphone

# # Two Restrictions :-

    # Every element isnide set should be hashable.
    # Hence we cannot list object as element in set.

    # Every key inside dictionary should be hashable.
    # For the key we cannot take list object.

# Ques: Write a program to accept student name and marks from the keyboard and with that data creates a dictionary. Also display student marks by taking student name as input?

n = int(input("Enter Number of Students:"))
d = {}

while len(d) <= n:
    name = input("Enter Student Name:")
    marks = int(input("Enter Student Marks:"))
    d[name] = marks

print("All Students Data Inserted")
print(d)

while True:
    name = input("Enter Student Name to get Marks:")
    if name in d:
        print("The Marks of {}:{}".format(name, d.get(name)))
    else:
        print("Student Not Found")

    option = input("Do you want to find another Student Marks [Yes|No]:")
    while option.lower() not in ["yes", "no"]:
        option = input("Invalid Option, Please choose Valid Option [Yes|No]:")

    if option.lower() == "no":
        break

print('Thanks for Using Our Application')

All Students Data Inserted
{'ram': 85, 'shyam': 93, 'harry': 75, 'pavan': 72}
Student Not Found
Student Not Found
The Marks of ram:85
Thanks for Using Our Application

# Dictionary Comprehension :-

# List ---> Applicable
# Tuple ---> Not Applicable
# Set ---> Applicabel
# Dict ---> Applicable

l = [x * x for x in range(1, 6)]
print(l)

[1, 4, 9, 16, 25]

# key:value
# {1:1, 2:4, 3:9, 4:16, 5:25}

# d = {key:value for x in range(1,6)}

d = {x: x * x for x in range(1, 6)}
print(d)

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

d = {x: x * 2 for x in range(1, 6)}
print(d)

{1: 2, 2: 4, 3: 6, 4: 8, 5: 10}

d = {x: chr(64 + x) for x in range(1, 27)}
print(d)

{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E', 6: 'F', 7: 'G', 8: 'H', 9: 'I', 10: 'J', 11: 'K', 12: 'L', 13: 'M', 14: 'N', 15: 'O', 16: 'P', 17: 'Q', 18: 'R', 19: 'S', 20: 'T', 21: 'U', 22: 'V', 23: 'W', 24: 'X', 25: 'Y', 26: 'Z'}

# # Implementation of Supermarket Dictionary :-

# supermarket has multiple stores
# Every store has a name
# Every store has multiple items
# Every item has name and quantity

# key-value
# for key ---> hashable
# for value ---> we can take anything

supermarket = {
    "store1": {
        "name": "DURGA GENERAL STORE",
        "items": [
            {"name": "soap", "quantity": 20},
            {"name": "brush", "quantity": 30},
            {"name": "paste", "quantity": 40},
        ],
    },
    "store2": {
        "name": "SUNNY BOOK STORE",
        "items": [
            {"name": "Python", "quantity": 5},
            {"name": "Django", "quantity": 15},
            {"name": "Devops", "quantity": 25},
            {"name": "Django", "quantity": 65},
        ],
    },
}

print(supermarket)

{'store1': {'name': 'DURGA GENERAL STORE', 'items': [{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]}, 'store2': {'name': 'SUNNY BOOK STORE', 'items': [{'name': 'Python', 'quantity': 5}, {'name': 'Django', 'quantity': 15}, {'name': 'Devops', 'quantity': 25}, {'name': 'Django', 'quantity': 65}]}}

# To print name of store1

print(supermarket['store1'])

{'name': 'DURGA GENERAL STORE', 'items': [{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]}

print(supermarket['store1']['name'])

DURGA GENERAL STORE

print(supermarket.get('store1'))

{'name': 'DURGA GENERAL STORE', 'items': [{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]}

print(supermarket.get('store1').get('name'))

DURGA GENERAL STORE

# To print names of all items present in store1

print(supermarket['store1']['items'])

[{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]

print(supermarket.get('store1').get('items'))

[{'name': 'soap', 'quantity': 20}, {'name': 'brush', 'quantity': 30}, {'name': 'paste', 'quantity': 40}]

for d in supermarket['store1']['items']:
    print(d['name'])

soap
brush
paste

for d in supermarket.get('store1').get('items'):
    print(d.get('name'))

soap
brush
paste

for d in supermarket.get('store1').get('items'):
    print(d)

{'name': 'soap', 'quantity': 20}
{'name': 'brush', 'quantity': 30}
{'name': 'paste', 'quantity': 40}

# How many django books are available?

for d in supermarket["store2"]["items"]:
    if d["name"] == "Django":
        print("The Number of Django Books:", d["quantity"])

The Number of Django Books: 15
The Number of Django Books: 65

# Ques: Which of the following allowed in Python?

# 1. List inside List
# 2. Tuple inside List
# 3. List inside Tuple
# 4. Tuple inside Set
# 5. List inside Set    ---> Invalid
# 6. Set inside Set     ---> Invalid
# 7. List as key in Dict   ---> Invalid
# 8. List as Value in Dict
# 9. Tuple as key in Dict
# 10. Tuple as Value in Dict
# 11. Set as key in Dict    ---> Invalid
# 12. Set as Value in Dict

s = {10,20,[30,40]}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[52], line 1
----> 1 s = {10,20,[30,40]}

TypeError: unhashable type: 'list'

s = {10,20,{30,40}}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[53], line 1
----> 1 s = {10,20,{30,40}}

TypeError: unhashable type: 'set'

# # Note :-

    # List, Set are not hashable types.
    # Every element inside set should be hashable. Hence we cannot take list, ste inside set.

    # Key of Dict should be hashable.
    # Hence we cannot take list, set as inside dict.

# List is unhashable, but how list inside list is accepted

    # In List and tuple, elements will be inserted based on order and index and PVM won't required any hash. Hence elements need not be hashable.

    # But in set and dict, elements will be inserted based on hash. Hence elements should be hashable.

d = {[10, 20]: "ram"}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[60], line 1
----> 1 d = {[10, 20]: "ram"}

TypeError: unhashable type: 'list'

d = {(10, 20): "ram"}

d = {{10, 20}: "ram"}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[62], line 1
----> 1 d = {{10, 20}: "ram"}

TypeError: unhashable type: 'set'

# # Functions :-

# DRY -- Principle
# Don't Repeat Yourself

# code reusability

def calc(a, b):
    print("Sum:", a + b)
    print("Product:", a * b)
    print("Difference:", a - b)
    print("Dividend:", a / b)


calc(10, 20)
calc(20, 30)

Sum: 30
Product: 200
Difference: -10
Dividend: 0.5
Sum: 50
Product: 600
Difference: -10
Dividend: 0.6666666666666666

# # Types of Functions :-

    # 1. Built in Functions

    # 2. User Defined Functions

# 1. Built in Functions :-

# predefined functions

# id()
# print()
# input()
# eval()
# len()

# 2. User Defined Functions :-

# syntax for user defined function :

    # def function_name(parameters):
        # ''' doc string '''
        # business logic
        # business logic
        # business logic
        # business logic
        # return value

# def ---> mandatory
# return ---> optional

# def m2(a,b):
    # some Code

# class Test:
    # def m1(self):
        # some code

# Functions inside class ---> Methods

# Ques: Write a function to print hello?

def wish():  # Defining a function
    print("hello")


wish()  # Calling a function

hello

wish()
print("hi")
wish()
print("hi")
wish()
print("hi")
wish()

hello
hi
hello
hi
hello
hi
hello

# Parameters :-

# Parameters are inputs to the function.
# If a function takes parameters, at the time of calling function, values.

def wish(name):
    print("Hello {}, Good Morning!".format(name))


wish("Harry")

Hello Harry, Good Morning!

name = input("Enter Name:")
wish(name)

Hello Harry, Good Morning!

# Ques: WAP to take number as arguments and print its square value?

def squareIt(number):
    print("The square of {} is : {}".format(number, number**2))


squareIt(4)
squareIt(5)
squareIt(6)
squareIt(7)

The square of 4 is : 16
The square of 5 is : 25
The square of 6 is : 36
The square of 7 is : 49

def add(x, y):
    print("The Sum of {} and {} is : {}".format(x, y, x + y))


add(10, 20)
add(20, 30)
add(30, 40)
add(40, 50)

The Sum of 10 and 20 is : 30
The Sum of 20 and 30 is : 50
The Sum of 30 and 40 is : 70
The Sum of 40 and 50 is : 90

# Return Statements :-

# Ques: WAF to accept 2 numbers as input and return sum?

def add(x, y):
    return x + y


result = add(10, 20)
print("Sum:", result)

Sum: 30

def add(x, y):
    print('Calling add function...')
    return x + y


add(10, 20)

Calling add function...

30

def validate(mobile_number):
    if len(mobile_number) == 10:
        return True
    else:
        return False


mobile_number = input("Enter Mobile Number:")
result = validate(mobile_number)
print(result)

True

def f1():
    print('Hello')

result = f1()
print(result)

Hello
None

# Every Function in Python in return some value.

# If you are not returning any value then by default return value is None.

x = 10
print(id(x))

140709881824328

print(print(x))

10
None

# Ques: WAF to check whether the given number is even or odd?

def even_odd(x):
    if x % 2 == 0:
        print("It is even number")
    else:
        print("It is odd number")


even_odd(15)
even_odd(10)

It is odd number
It is even number

even_odd(int(input('Enter Some Number to Check:')))

It is even number

def even_odd():
    x = int(input("Enter some Number:"))
    if x % 2 == 0:
        print("It is even number")
    else:
        print("It is odd number")


even_odd()

It is odd number

def even_odd(x):
    if x % 2 == 0:
        return "It is even number"
    else:
        return "It is odd number"

result = even_odd(15)
print(result)

It is odd number

def show(sequence):
    for x in sequence:
        print(x)


show("durga")
show(range(1, 6))

d
u
r
g
a
1
2
3
4
5

# Ques: WAF to find Factorial of given number?

def factorial(x):
    result = 1
    while x >= 1:
        result = result * x
        x = x - 1
    return result


for i in range(0, 11):
    print("The Factorial of {} is : {}".format(i, factorial(i)))

The Factorial of 0 is : 1
The Factorial of 1 is : 1
The Factorial of 2 is : 2
The Factorial of 3 is : 6
The Factorial of 4 is : 24
The Factorial of 5 is : 120
The Factorial of 6 is : 720
The Factorial of 7 is : 5040
The Factorial of 8 is : 40320
The Factorial of 9 is : 362880
The Factorial of 10 is : 3628800

def factorial(x):
    result = 1
    while x >= 1:
        result = result * x
        x = x - 1
    print("The Factorial of {} is : {}".format(x, result))


for i in range(0, 11):
    factorial(i)

The Factorial of 0 is : 1
The Factorial of 0 is : 1
The Factorial of 0 is : 2
The Factorial of 0 is : 6
The Factorial of 0 is : 24
The Factorial of 0 is : 120
The Factorial of 0 is : 720
The Factorial of 0 is : 5040
The Factorial of 0 is : 40320
The Factorial of 0 is : 362880
The Factorial of 0 is : 3628800

def calc(a, b):
    sum = a + b
    sub = a - b
    return sum, sub


x, y = calc(20, 10)
print(x, y)
print("Sum:", x)
print("Difference:", y)

30 10
Sum: 30
Difference: 10

x = calc(20, 10)
print(x)

(30, 10)

def calc(a, b):
    sum = a + b
    sub = a - b
    return [sum, sub]


x, y = calc(20, 10)
print(x, y)
print("Sum:", x)
print("Difference:", y)

x = calc(20, 10)
print(x)

30 10
Sum: 30
Difference: 10
[30, 10]

# Types of Arguments/Parameters :-

def f1(a, b):  # Formal Parameters
    pass


f1(10, 20)  # Arguments

# 4 Types of Parameters/Arguments :-
    # 1. Positional Arguments

    # 2. Keyword Arguments

    # 3. Default Arguments

    # 4. Varable Length Arguments

# 1. Positional Arguments :-

def sub(a, b):
    print(a - b)

sub(10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[7], line 1
----> 1 sub(10)

TypeError: sub() missing 1 required positional argument: 'b'

sub(10, 20)
sub(20, 10)
# The number of arguments must be matched
# The order of arguments is important, The result may be changed if we change order

-10
10

sub(10, 20, 30)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[12], line 1
----> 1 sub(10, 20, 30)

TypeError: sub() takes 2 positional arguments but 3 were given

# 2. Keyword Arguments :-

# We have to pass argument values by keyword i.e by paramter name.

# The number of arguments must be matched.

# The order is not important.

def sub(a, b):
    print(a - b)


sub(a=10, b=20)

-10

sub(a=10, b=20)

sub(b=20, a=10)

-10
-10

# # Note :-

    # We can use both positional arguments and keyword arguments simultaneously, but first positional arguments then keyword arguments.

    # But keyword arguments won't follow positional arguments.

    # Key name should be case sensitive.

def sub(a, b):
    print(a - b)

sub(a=10, b=20)

-10

sub(x=10, b=20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[28], line 1
----> 1 sub(x=10, b=20)

TypeError: sub() got an unexpected keyword argument 'x'

sub(10, b=20)

-10

sub(10, a=20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[32], line 1
----> 1 sub(10, a=20)

TypeError: sub() got multiple values for argument 'a'

sub(a=10, 20)

  Cell In[33], line 1
    sub(a=10, 20)
                ^
SyntaxError: positional argument follows keyword argument

sub(b=10, 20)

  Cell In[34], line 1
    sub(b=10, 20)
                ^
SyntaxError: positional argument follows keyword argument

def sub(a, b, c, d, e):
    print(a - b)


sub(10, 20, 30, 40, e=10)

-10

sub(10, 20, 30, 40, d=10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[37], line 1
----> 1 sub(10, 20, 30, 40, d=10)

TypeError: sub() got multiple values for argument 'd'

sub(10, 20, c=30, d=40, e=10)

-10

sub(10, 20, d=40, e=10, c=30)

-10

def wish(name, msg):
    print("Hello", name, msg)

wish("Durga", "Good Morning")

Hello Durga Good Morning

wish("Durga", msg="Good Morning")

Hello Durga Good Morning

wish(name ="Durga", "Good Morning")

  Cell In[45], line 1
    wish(name ="Durga", "Good Morning")
                                      ^
SyntaxError: positional argument follows keyword argument

wish(name="Durga", msg="Good Morning")

Hello Durga Good Morning

# 3. Default Arguments :-

def wish(name="Guest"):
    print("Hello", name, "Good Morning")

wish()

Hello Guest Good Morning

wish('Durga')

Hello Durga Good Morning

# Positional arguments and keywords arguments we have to take at the time of calling.

# But default arguments at the time of declaration.

wish(name ='Durga')

Hello Durga Good Morning

def wish(name="Guest", msg="Good Morning"):
    print("Hello", name, msg)

wish()

Hello Guest Good Morning

wish(name="Durga")

Hello Durga Good Morning

wish("Durga", msg="Good Evening")

Hello Durga Good Evening

wish("Good Evening")

Hello Good Evening Good Morning

wish(name="Durga", msg="Good Evening")

Hello Durga Good Evening

wish(msg="Good Evening")

Hello Guest Good Evening

wish(name="Durga", "Good Evening")

  Cell In[63], line 1
    wish(name="Durga", "Good Evening")
                                     ^
SyntaxError: positional argument follows keyword argument

def wish(name="Guest", msg="Good Morning"):
    pass

def wish(name, msg="Good Morning"):
    pass

def wish(name="Guest", msg):
    pass

  Cell In[66], line 1
    def wish(name="Guest", msg):
                           ^
SyntaxError: non-default argument follows default argument

# Default arguments should be last arguments. i.e after default arguments we cannot take non-default arguments.

def wish(msg, name="Guest"):
    pass

# 4. Variable Length Arguments :-

# Varaible number of arguments: at the time of declaration/definition.

def f(*x):
    print("The Type of x:", type(x))
    print("The Number of arguments passed:", len(x))

f()

The Type of x: <class 'tuple'>
The Number of arguments passed: 0

f(10)

The Type of x: <class 'tuple'>
The Number of arguments passed: 1

f(10, 20)

The Type of x: <class 'tuple'>
The Number of arguments passed: 2

f(10, 20, 30)

The Type of x: <class 'tuple'>
The Number of arguments passed: 3

f(10, 20, 30, 40)

The Type of x: <class 'tuple'>
The Number of arguments passed: 4

f(10, 20, 30, 40, 50, 60, 70, 80, 90)

The Type of x: <class 'tuple'>
The Number of arguments passed: 9

def sum(*n):
    total = 0
    for n1 in n:
        total = total + n1
    print("Sum:", total)

sum(10)

Sum: 10

sum(10, 20)

Sum: 30

sum(10, 20, 30, 40, 50, 60)

Sum: 210

sum()

Sum: 0

def sum(*n):
    for n1 in n:
        print(n1)

sum(10, "durga")

10
durga

def sum(*n):
    print(n)


sum(10, "durga")

(10, 'durga')

# We can use normal arguments and varaible length arguments simultaneously.

# We can take variable length argument anywhere.

def sum(n, *s):
    print(n)
    print(s)

sum(10, 20, 30, 40, 50)

10
(20, 30, 40, 50)

def sum(*s, n):
    print(s)
    print(n)

sum(10, 20, 30, 40, 50)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[104], line 1
----> 1 sum(10, 20, 30, 40, 50)

TypeError: sum() missing 1 required keyword-only argument: 'n'

sum(10, 20, 30, 40, 50, n=10)

(10, 20, 30, 40, 50)
10

# After variable lengtrh argument, if we are taking normal argument, we should provide value by using keyword only.

sum(10, 20, 30, 40, n=10, 50)

  Cell In[111], line 1
    sum(10, 20, 30, 40, n=10, 50)
                                ^
SyntaxError: positional argument follows keyword argument

def sum(*s, n=0):
    print(s)
    print(n)

sum(10, 20, 30, 40, 50)

(10, 20, 30, 40, 50)
0

sum(10, 20, 30, 40, 50, n=60)

(10, 20, 30, 40, 50)
60

def sum(n=0, *s):
    print(s)
    print(n)

sum(10, 20, 30, 40, 50, n=60)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[118], line 1
----> 1 sum(10, 20, 30, 40, 50, n=60)

TypeError: sum() got multiple values for argument 'n'

sum(n=60, 10, 20, 30, 40, 50)

  Cell In[119], line 1
    sum(n=60, 10, 20, 30, 40, 50)
                                ^
SyntaxError: positional argument follows keyword argument

sum(10, 20, 30, 40, 50)

(20, 30, 40, 50)
10

# After default arguments, we cannot take noraml arguments but we can take variable length arguments.

def sum(*m, *n):
    print(m)
    print(n)

  Cell In[122], line 1
    def sum(*m, *n):
                ^
SyntaxError: * argument may appear only once

# We cannot take more than one variable keyword argument.

def sum(*a, b, c, d, e):
    pass

sum(1, 2, 3, 4, 5)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[125], line 1
----> 1 sum(1, 2, 3, 4, 5)

TypeError: sum() missing 4 required keyword-only arguments: 'b', 'c', 'd', and 'e'

# 1. Positional Arguments
# 2. Keyword Arguments
# 3. Default Arguments
# 4. Variable Length Argumnets

# 1. Positional Arguments :-

    # At the time of calling

    # Order and Number are Important

def f1(a, b):
    print(a - b)


f1(10, 20)

-10

# 2. Keyword Arguments :-

    # At the time of calling

    # Order/Position is not Important

def f1(a, b):
    print(a - b)


f1(a=10, b=20)

-10

# We can use positional and keyword argumnets together but :

# First we should use positional argumnets and then keyword arguments.

# 3. Default Arguments :-

    # At the time of declaration/creation.

    # After taking default arguments, we cannot take normal arguments. But we can take variable length arguments.

def f1(a, b=0):
    print(a - b)


f1(a=10)
f1(a=10, b=20)

10
-10

def f1(a=0, b):
    print(a - b)


f1(a=10)
f1(a=10, b=20)

  Cell In[12], line 1
    def f1(a=0, b):
                ^
SyntaxError: non-default argument follows default argument

def f1(a=0, *b):
    print(a - b)


f1(a=10)
f1(a=10, b=20)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[13], line 5
      1 def f1(a=0, *b):
      2     print(a - b)
----> 5 f1(a=10)
      6 f1(a=10, b=20)

Cell In[13], line 2, in f1(a, *b)
      1 def f1(a=0, *b):
----> 2     print(a - b)

TypeError: unsupported operand type(s) for -: 'int' and 'tuple'

# 4. Variable Length Arguments :-

    # At the time of declaration/creation

    # We can take variable length arguments anywhere.

    # But after variable length argument, if we are taking any normal argument, compulsory we should pass value by keyword.

    # We can take only one variable-length argument.

def f1(*x):
    print(x)


f1(10, 20, 30, 40)

(10, 20, 30, 40)

def f1(*x, y):
    print(x)
    print(y)

f1(10, 20, 30, 40)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[19], line 1
----> 1 f1(10, 20, 30, 40)

TypeError: f1() missing 1 required keyword-only argument: 'y'

f1(10, 20, 30, y=40)

(10, 20, 30)
40

def fn(*var1, var2):
    print(var1)
    print(var2)


fn(10, "durga", 10.5, True, var2=40)

(10, 'durga', 10.5, True)
40

# *x ---> We can provide any number of values for x and x will become tuple.
# *args

# **x ---> We can pass any number of key-value pairs and x will become dict.
# **kwargs

def display(**kwargs):
    print(type(kwargs))
    print(kwargs)

display(10)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[25], line 1
----> 1 display(10)

TypeError: display() takes 0 positional arguments but 1 was given

display(name="Durga", rollno=101, narks=90)

<class 'dict'>
{'name': 'Durga', 'rollno': 101, 'narks': 90}

def display(**kwargs):
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(name="Durga", rollno=101, narks=90)

name=Durga
rollno=101
narks=90

# .items ---> provide list of items

def display(**kwargs):
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(name="Durga", rollno=101, narks=90)

dict_items([('name', 'Durga'), ('rollno', 101), ('narks', 90)])
name=Durga
rollno=101
narks=90

def display(*args, **kwargs):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90)

(10, 20, 30)
dict_items([('name', 'Durga'), ('rollno', 101), ('narks', 90)])
name=Durga
rollno=101
narks=90

def display(*args, **kwargs, x):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90)

  Cell In[35], line 1
    def display(*args, **kwargs, x):
                                 ^
SyntaxError: arguments cannot follow var-keyword argument

def display(*args, **kwargs, x=10):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90)

  Cell In[37], line 1
    def display(*args, **kwargs, x=10):
                                 ^
SyntaxError: arguments cannot follow var-keyword argument

# After varible length argument after **kwargs, it won't except any other type of argument.

def display(*args, **kwargs, x=10):
    print(args)
    print(kwargs.items())
    for k, v in kwargs.items():
        print("{}={}".format(k, v))


display(10, 20, 30, name="Durga", rollno=101, narks=90, x=10)

  Cell In[43], line 1
    def display(*args, **kwargs, x=10):
                                 ^
SyntaxError: arguments cannot follow var-keyword argument

# Rules to Remember :-

# 1. After keyword arguments, we cannot take positional arguments.

# 2. After default arguments, we cannit take normal arguments, but we can take variable length arguments.

# 3. After Variable length arguments, if we are taking any normal argument, compulsory we should provide values by keyword only.

# 4. We can take atmost one varaible length argument.

# 5. **kwargs should be last arguments.

def f1(arg1, arg2, arg3=4, arg4=8):
    print(arg1, arg2, arg3, arg4)

f1(3, 2)

3 2 4 8

f1(10, 20, 30, 40)

10 20 30 40

f1(25, 50, arg4=100)

25 50 4 100

f1(arg4=2, arg1=3, arg2=4)

3 4 4 2

f1()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[50], line 1
----> 1 f1()

TypeError: f1() missing 2 required positional arguments: 'arg1' and 'arg2'

f1(arg3=10, arg4=20, 30, 40)

  Cell In[52], line 1
    f1(arg3=10, arg4=20, 30, 40)
                               ^
SyntaxError: positional argument follows keyword argument

f1(4, 5, arg2=6)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[53], line 1
----> 1 f1(4, 5, arg2=6)

TypeError: f1() got multiple values for argument 'arg2'

f1(4, 5, arg3=5, arg5=6)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[54], line 1
----> 1 f1(4, 5, arg3=5, arg5=6)

TypeError: f1() got an unexpected keyword argument 'arg5'

def f1(*x, y=20):
    print(x)
    print(y)

f1(10, 20, 30, 777)

(10, 20, 30, 40)
20

f1(10, 20, 30, y=777)

(10, 20, 30)
777

# # Types of Variables/Variable Scopes :-

# 1. Global Variables
# 2. Local Variables

# 1. Global Variables :-

# The variables which are declared outside of the function
# Avaialable for all functions.

a = 10


def f1():
    print(a)


def f2():
    print(a)


f1()
f2()

10
10

# 2. Local Variables :-

# The variables which are declared inside of the function
# Avaialable only for that function.

def f1():
    b = 10
    print(b)


f1()

10

def f1():
    b = 10
    print(b)


def f2():
    print(b)


f1()
f2()

10

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[12], line 11
      7     print(b)
     10 f1()
---> 11 f2()

Cell In[12], line 7, in f2()
      6 def f2():
----> 7     print(b)

NameError: name 'b' is not defined

# Gloabl ===> Global to all functions.
# Local ===> Local to a particular function.

a = 10  # Global variable


def f1():
    a = 777  # Local variable
    print(a)


def f2():
    print(a)


f1()
f2()

777
10

# Global Keyword :-

# 1. To make global varaibles available to the functions so that we can perform required modifications.

a = 10  # Global variable


def f1():
    global a  # Make Global variable available to f1
    a = 777
    print(a)


def f2():
    print(a)


f1()
f2()

777
777

a = 10  # Global variable


def f1():
    global a = 777    # Make Global variable available to f1
    print(a)


def f2():
    print(a)


f1()
f2()

  Cell In[19], line 5
    global a = 777    # Make Global variable available to f1
             ^
SyntaxError: invalid syntax

# 2. To declare global variables inside functions.

def f1():
    global c  # Now onwards c is global varibale but not local variable
    c = 10
    print(c)


def f2():
    print(c)


f1()
f2()

10
10

def f1():
    global d  # Now onwards d is global varibale but not local variable
    d = 10
    print(d)


def f2():
    print(d)


f2()

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[16], line 11
      7 def f2():
      8     print(d)
---> 11 f2()

Cell In[16], line 8, in f2()
      7 def f2():
----> 8     print(d)

NameError: name 'd' is not defined

def f1():
    global e  # Now onwards e is global varibale but not local variable
    e = 10
    print(e)


def f2():
    e = 777
    print(e)


f1()
f2()
print(e)

10
777
10

f = 10


def f1():
    f = 777
    print(f)


f1()
print(f)

777
10

# How to print global varibale value inside fuction containing local variable.

# If the local and global varibale have the same name then how to differentiate values?

a1 = 10


def f1():
    a1 = 777
    print("Local Variable Value:", a1)

    # How to print global variable value of 'a1'
    global a1
    print("Global Variable Value:", a1)


f1()

  Cell In[30], line 9
    global a1
    ^
SyntaxError: name 'a1' is used prior to global declaration

a1 = 10


def f1():
    a1 = 777
    print("Local Variable Value:", a1)

    # How to print global variable value of 'a1'
    print("Global Variable Value:", globals())


f1()

Local Variable Value: 777
Global Variable Value: {'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', 'a = 10\n\n\ndef f1():\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a\n    a = 777     # Local variable\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# # Global Keyword :-', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '# 2. ', '# 2. To declare global variables inside functions.', 'def f1():\n    global c    # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global d  # Now onwards c is global varibale but not local variable\n    d = 10\n    print(d)\n\n\ndef f2():\n    print(d)\n\n\nf2()', 'def f1():\n    global e  # Now onwards e is global varibale but not local variable\n    e = 10\n    print(e)\n\n\ndef f2():\n    e = 777\n    print(e)\n\nf1()\nf2()\nprint(e)', 'a = 10  # Global variable\n\n\ndef f1():\n    global a  # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '# How to print global varibale value inside fuction containing local variable', '# How to print global varibale value inside fuction containing local variable.\n\n# If the local and global varibale have the same name then how to differentiate values?', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals(a1))\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()'], '_oh': {}, '_dh': [WindowsPath('c:/Users/pulki/Python/python_fundamentals')], 'In': ['', 'a = 10\n\n\ndef f1():\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a\n    a = 777     # Local variable\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# # Global Keyword :-', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '# 2. ', '# 2. To declare global variables inside functions.', 'def f1():\n    global c    # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', 'def f1():\n    global d  # Now onwards c is global varibale but not local variable\n    d = 10\n    print(d)\n\n\ndef f2():\n    print(d)\n\n\nf2()', 'def f1():\n    global e  # Now onwards e is global varibale but not local variable\n    e = 10\n    print(e)\n\n\ndef f2():\n    e = 777\n    print(e)\n\nf1()\nf2()\nprint(e)', 'a = 10  # Global variable\n\n\ndef f1():\n    global a  # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '# How to print global varibale value inside fuction containing local variable', '# How to print global varibale value inside fuction containing local variable.\n\n# If the local and global varibale have the same name then how to differentiate values?', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals(a1))\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()'], 'Out': {}, 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0000021A49C68B50>>, 'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000021A49C75990>, 'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000021A49C75990>, 'open': <function open at 0x0000021A47C06AC0>, '_': '', '__': '', '___': '', '__vsc_ipynb_file__': 'c:\\Users\\pulki\\Python\\python_fundamentals\\58_Types_of_Variables.ipynb', '_i': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', '_ii': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', '_iii': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', '_i1': 'a = 10\n\n\ndef f1():\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', 'a': 777, 'f1': <function f1 at 0x0000021A49D6A2A0>, 'f2': <function f2 at 0x0000021A4A29D620>, '_i2': 'a = 10  # Global variable\n\n\ndef f1():\n    global a\n    a = 777     # Local variable\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i3': 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i4': '# # Global Keyword :-', '_i5': 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i6': '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '_i7': 'a = 10  # Global variable\n\n\ndef f1():\n    global a    # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i8': 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i9': '# 1. To make global varaibles available to the functions so that we can perform required modifications.', '_i10': '# 2. ', '_i11': '# 2. To declare global variables inside functions.', '_i12': 'def f1():\n    global c    # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', 'c': 10, '_i13': 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', '_i14': 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf1()\nf2()', '_i15': 'def f1():\n    global c  # Now onwards c is global varibale but not local variable\n    c = 10\n    print(c)\n\n\ndef f2():\n    print(c)\n\n\nf2()', '_i16': 'def f1():\n    global d  # Now onwards c is global varibale but not local variable\n    d = 10\n    print(d)\n\n\ndef f2():\n    print(d)\n\n\nf2()', '_i17': 'def f1():\n    global e  # Now onwards e is global varibale but not local variable\n    e = 10\n    print(e)\n\n\ndef f2():\n    e = 777\n    print(e)\n\nf1()\nf2()\nprint(e)', 'e': 10, '_i18': 'a = 10  # Global variable\n\n\ndef f1():\n    global a  # Make Global variable available to f1\n    a = 777\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i19': 'a = 10  # Global variable\n\n\ndef f1():\n    global a = 777    # Make Global variable available to f1\n    print(a)\n\n\ndef f2():\n    print(a)\n\n\nf1()\nf2()', '_i20': 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()', 'f': 10, '_i21': 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '_i22': 'f = 10\n\n\ndef f1():\n    f = 777\n    print(f)\n\n\nf1()\nprint(f)', '_i23': '# How to print global varibale value inside fuction containing local variable', '_i24': '# How to print global varibale value inside fuction containing local variable.\n\n# If the local and global varibale have the same name then how to differentiate values?', '_i25': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()\nprint(f)', 'a1': 10, '_i26': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals(a1))\n\n\nf1()\nprint(f)', '_i27': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()\nprint(f)', '_i28': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals()[\'a1\'])\n\n\nf1()\nprint(f)', '_i29': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()', '_i30': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    global a1\n    print("Global Variable Value:", a1)\n\n\nf1()', '_i31': 'a1 = 10\n\n\ndef f1():\n    a1 = 777\n    print("Local Variable Value:", a1)\n\n    # How to print global variable value of \'a1\'\n    print("Global Variable Value:", globals())\n\n\nf1()'}

a1 = 10


def f1():
    a1 = 777
    print("Local Variable Value:", a1)

    # How to print global variable value of 'a1'
    print("Global Variable Value:", globals()['a1'])
    print("Global Variable Value:", globals().get('a1'))


f1()

Local Variable Value: 777
Global Variable Value: 10
Global Variable Value: 10

a = 10
for i in range(1):
    b = 20

print(a, b)

10 20

# # Recursive Functions :-

# A function that calls itself is known as Recursive Function.

# factorial(n) = n * (n-1) * (n-2) * ....1
# factorial(n) = n * factorial(n-1)

# 1. We can reduce the length of the code and improves readability.

# 2. We can solve very complex problems also very easily.

def factorial(n):
    print("Finding Factorial of", n)
    if n == 0:
        result = 1
    else:
        result = n * factorial(n - 1)

    print("Completion of Finding Factorial of {} and Result is {}".format(n, result))
    return result


print("Factorial :", factorial(4))

Finding Factorial of 4
Finding Factorial of 3
Finding Factorial of 2
Finding Factorial of 1
Finding Factorial of 0
Completion of Finding Factorial of 0 and Result is 1
Completion of Finding Factorial of 1 and Result is 1
Completion of Finding Factorial of 2 and Result is 2
Completion of Finding Factorial of 3 and Result is 6
Completion of Finding Factorial of 4 and Result is 24
Factorial : 24

def fib(n):
    if n == 0:
        return 0
    elif n == 1 or n == 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)


print(fib(4))

3

print(fib(5))

5

print(fib(6))

8

# # Anonymous Fuctions/ Lambda Functions :-

# Nameless functions are called anonymous functions.

# # Normal Function :-

    # By using def keyword
    # function name: squareIt

def squareIt(n):
    return n * n

# Anonymous Function :-

# We have to use lambda keyword

# lambda n : n * n
# lambda arguments_list:expression

s = lambda n: n * n
print("The Square is {}".format(s(4)))

The Square is 16

# Lambda Function to find sum of 2 given numbers?

s = lambda a, b: a + b
print("Sum:", s(10, 20))

Sum: 30

# To find biggest of 2 numbers?

s = lambda a, b: a if a > b else b
print("Biggest Number is", s(10, 20))

Biggest Number is 20

# To find biggest of 3 numbers?

s = lambda a, b, c: a if a > b and a > c else b if b > c else c
print("Biggest Number is", s(10, 20, 30))

Biggest Number is 30

# # Python Lambda functions are always single line functions only.

# # Lmabda Functions :-

# We can pass a function as argument to another functions.
# In such cases Lambda functions are best choice.

# filter()
# map()
# reduce()

# 1. filter() Function :-

# To filter values based on some condition.

# 10 values filter top 3 values.

# 10 numbers filter only even numbers.

# input = [1, 2, 3, 4, 5, 6, 7, 8]

# [2, 4, 6, 8]

# filter(function, sequence)

def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False


l = [0, 5, 10, 15, 20, 25]
output = filter(is_even, l)
print(type(output))
print(output)

<class 'filter'>
<filter object at 0x0000026C05F20DF0>

l = [0, 5, 10, 15, 20, 25]
output = list(filter(is_even, l))
print(type(output))
print(output)

<class 'list'>
[0, 10, 20]

def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False


l = [0, 5, 10, 15, 20, 25]
output = []
for x in l:
    if is_even(x) == True:
        output.append(x)

print(type(output))
print(output)

<class 'list'>
[0, 10, 20]

# It means filter internally looping for each value present in list.

def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False


lambda n: n % 2 == 0

<function __main__.<lambda>(n)>

l = [0, 5, 10, 15, 20, 25]
evens = list(filter(lambda n: n % 2 == 0, l))
odds = list(filter(lambda n: n % 2 != 0, l))

print(evens)
print(odds)

[0, 10, 20]
[5, 15, 25]

t = ("A", "AA", "AAA", "AAAA", "AAAAA")
# return all strings where length is >= 3

output = list(filter(lambda s: len(s) >= 3, t))
print(output)

['AAA', 'AAAA', 'AAAAA']

# List of employee objects. List out all employees which can go to pub?
#  his salary is > 10000 and he has gf and his age > 21

# l = [e1, e2, e3, e4]
# output = filter(lambda e:e.sal > 10000 and e.age > 21 and e.hasgf == True, l)

# 2. map() Function :-

# filter()
    # input : 10 elements
    #  output : 10 or less

# map()
    # input : 10 elements
    # output : 10 elements

# For every input value, generate output value based on some operation increment 10% salary for every employee.

# map(function, sequence)

def squarIt(n):
    return n * n


l = [1, 2, 3, 4, 5]
m = map(squarIt, l)
print(type(m))
print(m)

<class 'map'>
<map object at 0x00000216D4BB6530>

l = [1, 2, 3, 4, 5]
m = list(map(squarIt, l))
print(type(m))
print(m)

<class 'list'>
[1, 4, 9, 16, 25]

# # without lambda function :-

def squarIt(n):
    return n * n


l = [1, 2, 3, 4, 5]
m = list(map(squarIt, l))
print(type(m))
print(m)

# # with lambda function :-

l = [1, 2, 3, 4, 5]
m = list(map(lambda n: n * n, l))
print(type(m))
print(m)

<class 'list'>
[1, 4, 9, 16, 25]
<class 'list'>
[1, 4, 9, 16, 25]

l = [1, 2, 3, 4, 5]
m = list(map(lambda n: 2 * n, l))
print(m)

[2, 4, 6, 8, 10]

l = [0, 5, 10, 15, 20, 25]

# list out all odd numberws from the list

output = list(filter(lambda n: n % 2 != 0, l))
print(output)

[5, 15, 25]

# list out all numbers which are divisible by 3

output = list(filter(lambda n: n % 3 == 0, l))
print(output)

[0, 15]

# list = [0, 5, 10, 15, 20, 25]

# # list out all odd numberws from the list

# output = list(filter(lambda n: n % 2 != 0, list))
# print(output)

# # TypeError                                 Traceback (most recent call last)
# # Cell In[3], line 5
# #       1 list = [0, 5, 10, 15, 20, 25]
# #       3 # list out all odd numberws from the list
# # ----> 5 output = list(filter(lambda n: n % 2 != 0, list))
# #       6 print(output)

# # TypeError: 'list' object is not callable

list1 = [0, 5, 10, 15, 20, 25]

# list out all odd numberws from the list

output = list(filter(lambda n: n % 2 != 0, list1))
print(output)

[5, 15, 25]

# create a new list with double of values present in list1

output = list(map(lambda n: 2 * n, list1))
print(output)

[0, 10, 20, 30, 40, 50]

# create a new list with numbers which are divisible by 3

output = list(map(lambda n: n % 3 == 0, list1))
print(output)

[True, False, False, True, False, False]

# input : 10 values

# output :
#     filter()    ---> 10 or less
#     map()       ---> 10

# map(function, list)

# We can use map function on multiple list also

l1 = [1, 2, 3, 4]
l2 = [10, 20, 30, 40]

# Generate output by multiplying values from both lists

output = list(map(lambda x, y: x * y, l1, l2))
print(output)

[10, 40, 90, 160]

l1 = [1, 2, 3, 4, 5]
l2 = [10, 20, 30, 40, 50, 60, 70]

# Generate output by multiplying values from both lists

output = list(map(lambda x, y: x * y, l1, l2))
print(output)

[10, 40, 90, 160, 250]

# 3. reduce() Function :-

# reduce(function, sequence)

# input : 10 values

# output :
#     filter()    ---> 10 or less
#     map()       ---> 10
#     reduce()    ---> 1

l = [10, 20, 30, 40, 50]

result = reduce(lambda x, y: x + y, l)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[18], line 3
      1 l = [10, 20, 30, 40, 50]
----> 3 result = reduce(lambda x,y:x+y,)

NameError: name 'reduce' is not defined

from functools import *

l = [10, 20, 30, 40, 50]

result = reduce(lambda x, y: x + y, l)
print(result)

150

# print the sum of numbers from 1 to 100

result = reduce(lambda x, y: x + y, range(1, 101))
print(result)

5050

result = reduce(lambda x, y: x * y, range(1, 4))
print(result)

6

def multiply(x, y):
    return x * y


result = reduce(multiply, range(1, 4))
print(result)

6

# In the above example we have not pass the parameter to multiply then how it is working?

# We are not calling multiple fucntion. reduce() function is calling internally.

# # Modules :-

# A group of functions, variables and classes saved to a file, which is nothing but module.

# Every Python file (.py file) is a module.

# Advantages of Module :-
    # 1. Code Reusability

    # 2. Readability

    # 3. Maintainability

    # 4. Development Time

    # 5. Cost of Project

x = 888
name = "DURGASOFT"


def add(a, b):
    print("SUM : ", a + b)


def product(a, b):
    print("PRODUCT : ", a * b)


# Save by file name durgamath.py

# import modulename
# modulename.varaiblename
# modulename.functionname()

import durgamath
print(durgamath.x)
print(durgamath.name)

888
DURGASOFT

durgamath.add(10, 20)

SUM :  30

durgamath.product(10, 20)

PRODUCT :  200

# .pyc file will be generated for modules in __pycache__ which we wrote when we call them or when we use.

# .pyc file will be not generated for normal .py file unless we use it as a module.

# Module Name Aliasing :-

import durgamath as dm

print(dm.x)
print(dm.name)
dm.add(10, 20)
dm.product(10, 20)

888
DURGASOFT
SUM :  30
PRODUCT :  200

# Once we define alias name, we cannot use original name.

# from import :-

# Usually we can acces members of a module by using module name.

# If we don't want to use module name then we should go for from import.

# We can access members directly.

from durgamath import x, name

print(x)
print(name)

888
DURGASOFT

add(10,20)

SUM :  30

from durgamath import *     # to import everything from file

print(dm.x)
print(dm.name)
dm.add(10, 20)
dm.product(10, 20)

888
DURGASOFT
SUM :  30
PRODUCT :  200

# We can write import statement anywhere in the code it is not compulsory to add import as 1st statement.

# Member Aliasing :-

from durgamath import add as a, product as b, name as n

print(n)
a(10, 20)
b(10, 20)

DURGASOFT
SUM :  30
PRODUCT :  200

a(10, 20, 30)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[21], line 1
----> 1 a(10, 20, 30)

TypeError: add() takes 2 positional arguments but 3 were given

# from durgamath as dm import add as a, product as p

# is this right?

# No, it is not correct.

# Various Possibilities of import :-

# import module1
# import module1, module2, module3
# import module1 as m1
# import module1 as m1, module2 as m2, module3 as m3
# from module1 import member1
# from module1 import member1, member2, member3
# from module import *
# from module import member1 as m1
# from module import member1 as m1, member2 as m2

# from module1, module2 import *    ===> Invalid

# Module Naming Conflicts :-

from module1 import *

add(10, 20)

module1 add function
SUM: 30

from module2 import *

add(10, 20)

module2 add function
SUM: 30

from module1 import *
from module2 import *

add(10, 20)

module2 add function
SUM: 30

from module1 import *
from module2 import *


def add(a, b):
    print("Current Module Add Function")
    print("SUM:", a + b)


add(10, 20)

Current Module Add Function
SUM: 30

from module1 import *


def add(a, b):
    print("Current Module Add Function")
    print("SUM:", a + b)


from module2 import *

add(10, 20)

module2 add function
SUM: 30

# In the case of conflicts, python will always consider the most recent copy.

x = 10
print(x)
x = 20
print(x)
x = 30
print(x)

10
20
30

# The most recent copy ---> order wise which is avaialable at last.

# How to call module1 add function?

# Two Ways :-

# 1st way :-

import module1
import module2

module1.add(10, 20)
module2.add(10, 20)

module1 add function
SUM: 30
module2 add function
SUM: 30

# 2nd way :-

from module1 import add as m1
from module2 import add as m2

m1.add(10, 20)
m2.add(10, 20)

module1 add function
SUM: 30
module2 add function
SUM: 30

# # Reloading of Module :-

# import module will be loading only once in PVM whether you call it in multiple files multiple times.

# By default module will be loaded only once eventhough we are importing multiple times.

# Advantage :-
    # Performance is more

# Problem :-
    # We are missing updations of that module.

import module1

module1.add(10, 20)

module1 add function
SUM: 30

import module1

module1.add(10, 20)

module1 add function
SUM: 30

import time
import module1

module1.add(10, 20)
print("Progrsam Entering into Sleeping State")
time.sleep(45)
print("Just Wake up and calling Updated Fuction")
import module1

module1.product(10, 20)

module1 add function
SUM: 30
Progrsam Entering into Sleeping State
Just Wake up and calling Updated Fuction

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[52], line 10
      7 print("Just Wake up and calling Updated Fuction")
      8 import module1
---> 10 module1.product(10, 20)

AttributeError: module 'module1' has no attribute 'product'

# reload()
# imp module

import time
import imp
import module1

module1.add(10, 20)
print("Progrsam Entering into Sleeping State")
time.sleep(45)
print("Just Wake up and calling Updated Fuction")
imp.reload(module1)

module1.product(10, 20)

C:\Users\pulki\AppData\Local\Temp\ipykernel_7632\3697301949.py:2: DeprecationWarning: the imp module is deprecated in favour of importlib and slated for removal in Python 3.12; see the module's documentation for alternative uses
  import imp

module1 add function
SUM: 30
Progrsam Entering into Sleeping State
Just Wake up and calling Updated Fuction
PRODUCT : 200

# My Python Program keep on printing share price values.
# Some module is available to provide shares data.

# Without Reloading program if we run program second time updation is occur?

# PVM will be stopped
# PVM will be started again

# dir() and help() functions :-

# Finding Members of Module by using dir() function :-

# Just To list out members of a module

# dir() ---> To listout members of current module
# dir(module_name) ---> To listout members of specified module

a = 10
b = 20


def add(a, b):
    return a + b


def product(a, b):
    return a * b

# To listout all members of current module
print(dir())

['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__vsc_ipynb_file__', '_dh', '_i', '_i1', '_i2', '_i3', '_ih', '_ii', '_iii', '_oh', 'a', 'add', 'b', 'exit', 'get_ipython', 'module1', 'open', 'product', 'quit']

# For every module, PVM will add several predefined variables, which are internally used by PVM. Even these varaibles can be used by programmer based on his requirement.

# To list out all members of math module

import math

print(dir(math))

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

# Help documentation of a Module :-

# help()

import math

help(math)

Help on built-in module math:

NAME
    math

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.
        
        The result is between 0 and pi.
    
    acosh(x, /)
        Return the inverse hyperbolic cosine of x.
    
    asin(x, /)
        Return the arc sine (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    asinh(x, /)
        Return the inverse hyperbolic sine of x.
    
    atan(x, /)
        Return the arc tangent (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    atan2(y, x, /)
        Return the arc tangent (measured in radians) of y/x.
        
        Unlike atan(y/x), the signs of both x and y are considered.
    
    atanh(x, /)
        Return the inverse hyperbolic tangent of x.
    
    cbrt(x, /)
        Return the cube root of x.
    
    ceil(x, /)
        Return the ceiling of x as an Integral.
        
        This is the smallest integer >= x.
    
    comb(n, k, /)
        Number of ways to choose k items from n items without repetition and without order.
        
        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates
        to zero when k > n.
        
        Also called the binomial coefficient because it is equivalent
        to the coefficient of k-th term in polynomial expansion of the
        expression (1 + x)**n.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    copysign(x, y, /)
        Return a float with the magnitude (absolute value) of x but the sign of y.
        
        On platforms that support signed zeros, copysign(1.0, -0.0)
        returns -1.0.
    
    cos(x, /)
        Return the cosine of x (measured in radians).
    
    cosh(x, /)
        Return the hyperbolic cosine of x.
    
    degrees(x, /)
        Convert angle x from radians to degrees.
    
    dist(p, q, /)
        Return the Euclidean distance between two points p and q.
        
        The points should be specified as sequences (or iterables) of
        coordinates.  Both inputs must have the same dimension.
        
        Roughly equivalent to:
            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))
    
    erf(x, /)
        Error function at x.
    
    erfc(x, /)
        Complementary error function at x.
    
    exp(x, /)
        Return e raised to the power of x.
    
    exp2(x, /)
        Return 2 raised to the power of x.
    
    expm1(x, /)
        Return exp(x)-1.
        
        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
    
    fabs(x, /)
        Return the absolute value of the float x.
    
    factorial(n, /)
        Find n!.
        
        Raise a ValueError if x is negative or non-integral.
    
    floor(x, /)
        Return the floor of x as an Integral.
        
        This is the largest integer <= x.
    
    fmod(x, y, /)
        Return fmod(x, y), according to platform C.
        
        x % y may differ.
    
    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).
        
        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
    
    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.
        
        Assumes IEEE-754 floating point arithmetic.
    
    gamma(x, /)
        Gamma function at x.
    
    gcd(*integers)
        Greatest Common Divisor.
    
    hypot(...)
        hypot(*coordinates) -> value
        
        Multidimensional Euclidean distance from the origin to a point.
        
        Roughly equivalent to:
            sqrt(sum(x**2 for x in coordinates))
        
        For a two dimensional point (x, y), gives the hypotenuse
        using the Pythagorean theorem:  sqrt(x*x + y*y).
        
        For example, the hypotenuse of a 3/4/5 right triangle is:
        
            >>> hypot(3.0, 4.0)
            5.0
    
    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
        Determine whether two floating point numbers are close in value.
        
          rel_tol
            maximum difference for being considered "close", relative to the
            magnitude of the input values
          abs_tol
            maximum difference for being considered "close", regardless of the
            magnitude of the input values
        
        Return True if a is close in value to b, and False otherwise.
        
        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.
        
        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
        is, NaN is not close to anything, even itself.  inf and -inf are
        only close to themselves.
    
    isfinite(x, /)
        Return True if x is neither an infinity nor a NaN, and False otherwise.
    
    isinf(x, /)
        Return True if x is a positive or negative infinity, and False otherwise.
    
    isnan(x, /)
        Return True if x is a NaN (not a number), and False otherwise.
    
    isqrt(n, /)
        Return the integer part of the square root of the input.
    
    lcm(*integers)
        Least Common Multiple.
    
    ldexp(x, i, /)
        Return x * (2**i).
        
        This is essentially the inverse of frexp().
    
    lgamma(x, /)
        Natural logarithm of absolute value of Gamma function at x.
    
    log(...)
        log(x, [base=math.e])
        Return the logarithm of x to the given base.
        
        If the base not specified, returns the natural logarithm (base e) of x.
    
    log10(x, /)
        Return the base 10 logarithm of x.
    
    log1p(x, /)
        Return the natural logarithm of 1+x (base e).
        
        The result is computed in a way which is accurate for x near zero.
    
    log2(x, /)
        Return the base 2 logarithm of x.
    
    modf(x, /)
        Return the fractional and integer parts of x.
        
        Both results carry the sign of x and are floats.
    
    nextafter(x, y, /)
        Return the next floating-point value after x towards y.
    
    perm(n, k=None, /)
        Number of ways to choose k items from n items without repetition and with order.
        
        Evaluates to n! / (n - k)! when k <= n and evaluates
        to zero when k > n.
        
        If k is not specified or is None, then k defaults to n
        and the function returns n!.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    pow(x, y, /)
        Return x**y (x to the power of y).
    
    prod(iterable, /, *, start=1)
        Calculate the product of all the elements in the input iterable.
        
        The default start value for the product is 1.
        
        When the iterable is empty, return the start value.  This function is
        intended specifically for use with numeric values and may reject
        non-numeric types.
    
    radians(x, /)
        Convert angle x from degrees to radians.
    
    remainder(x, y, /)
        Difference between x and the closest integer multiple of y.
        
        Return x - n*y where n*y is the closest integer multiple of y.
        In the case where x is exactly halfway between two multiples of
        y, the nearest even value of n is used. The result is always exact.
    
    sin(x, /)
        Return the sine of x (measured in radians).
    
    sinh(x, /)
        Return the hyperbolic sine of x.
    
    sqrt(x, /)
        Return the square root of x.
    
    tan(x, /)
        Return the tangent of x (measured in radians).
    
    tanh(x, /)
        Return the hyperbolic tangent of x.
    
    trunc(x, /)
        Truncates the Real x to the nearest Integral toward 0.
        
        Uses the __trunc__ magic method.
    
    ulp(x, /)
        Return the value of the least significant bit of the float x.

DATA
    e = 2.718281828459045
    inf = inf
    nan = nan
    pi = 3.141592653589793
    tau = 6.283185307179586

FILE
    (built-in)

import random

help(random)

Help on module random:

NAME
    random - Random variable generators.

MODULE REFERENCE
    https://docs.python.org/3.11/library/random.html
    
    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
        bytes
        -----
               uniform bytes (values between 0 and 255)
    
        integers
        --------
               uniform within range
    
        sequences
        ---------
               pick random element
               pick random sample
               pick weighted random sample
               generate random permutation
    
        distributions on the real line:
        ------------------------------
               uniform
               triangular
               normal (Gaussian)
               lognormal
               negative exponential
               gamma
               beta
               pareto
               Weibull
    
        distributions on the circle (angles 0 to 2pi)
        ---------------------------------------------
               circular uniform
               von Mises
    
    General notes on the underlying Mersenne Twister core generator:
    
    * The period is 2**19937-1.
    * It is one of the most extensively tested generators in existence.
    * The random() method is implemented in C, executes in a single Python step,
      and is, therefore, threadsafe.

CLASSES
    _random.Random(builtins.object)
        Random
            SystemRandom
    
    class Random(_random.Random)
     |  Random(x=None)
     |  
     |  Random number generator base class used by bound module functions.
     |  
     |  Used to instantiate instances of Random to get generators that don't
     |  share state.
     |  
     |  Class Random can also be subclassed if you want to use a different basic
     |  generator of your own devising: in that case, override the following
     |  methods:  random(), seed(), getstate(), and setstate().
     |  Optionally, implement a getrandbits() method so that randrange()
     |  can cover arbitrarily large ranges.
     |  
     |  Method resolution order:
     |      Random
     |      _random.Random
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __getstate__(self)
     |      Helper for pickle.
     |  
     |  __init__(self, x=None)
     |      Initialize an instance.
     |      
     |      Optional argument x controls seeding, as for Random.seed().
     |  
     |  __reduce__(self)
     |      Helper for pickle.
     |  
     |  __setstate__(self, state)
     |  
     |  betavariate(self, alpha, beta)
     |      Beta distribution.
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      Returned values range between 0 and 1.
     |  
     |  choice(self, seq)
     |      Choose a random element from a non-empty sequence.
     |  
     |  choices(self, population, weights=None, *, cum_weights=None, k=1)
     |      Return a k sized list of population elements chosen with replacement.
     |      
     |      If the relative weights or cumulative weights are not specified,
     |      the selections are made with equal probability.
     |  
     |  expovariate(self, lambd)
     |      Exponential distribution.
     |      
     |      lambd is 1.0 divided by the desired mean.  It should be
     |      nonzero.  (The parameter would be called "lambda", but that is
     |      a reserved word in Python.)  Returned values range from 0 to
     |      positive infinity if lambd is positive, and from negative
     |      infinity to 0 if lambd is negative.
     |  
     |  gammavariate(self, alpha, beta)
     |      Gamma distribution.  Not the gamma function!
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      
     |      The probability distribution function is:
     |      
     |                  x ** (alpha - 1) * math.exp(-x / beta)
     |        pdf(x) =  --------------------------------------
     |                    math.gamma(alpha) * beta ** alpha
     |  
     |  gauss(self, mu=0.0, sigma=1.0)
     |      Gaussian distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.  This is
     |      slightly faster than the normalvariate() function.
     |      
     |      Not thread-safe without a lock around calls.
     |  
     |  getstate(self)
     |      Return internal state; can be passed to setstate() later.
     |  
     |  lognormvariate(self, mu, sigma)
     |      Log normal distribution.
     |      
     |      If you take the natural logarithm of this distribution, you'll get a
     |      normal distribution with mean mu and standard deviation sigma.
     |      mu can have any value, and sigma must be greater than zero.
     |  
     |  normalvariate(self, mu=0.0, sigma=1.0)
     |      Normal distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.
     |  
     |  paretovariate(self, alpha)
     |      Pareto distribution.  alpha is the shape parameter.
     |  
     |  randbytes(self, n)
     |      Generate n random bytes.
     |  
     |  randint(self, a, b)
     |      Return random integer in range [a, b], including both end points.
     |  
     |  randrange(self, start, stop=None, step=1)
     |      Choose a random item from range(stop) or range(start, stop[, step]).
     |      
     |      Roughly equivalent to ``choice(range(start, stop, step))`` but
     |      supports arbitrarily large ranges and is optimized for common cases.
     |  
     |  sample(self, population, k, *, counts=None)
     |      Chooses k unique random elements from a population sequence.
     |      
     |      Returns a new list containing elements from the population while
     |      leaving the original population unchanged.  The resulting list is
     |      in selection order so that all sub-slices will also be valid random
     |      samples.  This allows raffle winners (the sample) to be partitioned
     |      into grand prize and second place winners (the subslices).
     |      
     |      Members of the population need not be hashable or unique.  If the
     |      population contains repeats, then each occurrence is a possible
     |      selection in the sample.
     |      
     |      Repeated elements can be specified one at a time or with the optional
     |      counts parameter.  For example:
     |      
     |          sample(['red', 'blue'], counts=[4, 2], k=5)
     |      
     |      is equivalent to:
     |      
     |          sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
     |      
     |      To choose a sample from a range of integers, use range() for the
     |      population argument.  This is especially fast and space efficient
     |      for sampling from a large population:
     |      
     |          sample(range(10000000), 60)
     |  
     |  seed(self, a=None, version=2)
     |      Initialize internal state from a seed.
     |      
     |      The only supported seed types are None, int, float,
     |      str, bytes, and bytearray.
     |      
     |      None or no argument seeds from current time or from an operating
     |      system specific randomness source if available.
     |      
     |      If *a* is an int, all bits are used.
     |      
     |      For version 2 (the default), all of the bits are used if *a* is a str,
     |      bytes, or bytearray.  For version 1 (provided for reproducing random
     |      sequences from older versions of Python), the algorithm for str and
     |      bytes generates a narrower range of seeds.
     |  
     |  setstate(self, state)
     |      Restore internal state from object returned by getstate().
     |  
     |  shuffle(self, x)
     |      Shuffle list x in place, and return None.
     |  
     |  triangular(self, low=0.0, high=1.0, mode=None)
     |      Triangular distribution.
     |      
     |      Continuous distribution bounded by given lower and upper limits,
     |      and having a given mode value in-between.
     |      
     |      http://en.wikipedia.org/wiki/Triangular_distribution
     |  
     |  uniform(self, a, b)
     |      Get a random number in the range [a, b) or [a, b] depending on rounding.
     |  
     |  vonmisesvariate(self, mu, kappa)
     |      Circular data distribution.
     |      
     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and
     |      kappa is the concentration parameter, which must be greater than or
     |      equal to zero.  If kappa is equal to zero, this distribution reduces
     |      to a uniform random angle over the range 0 to 2*pi.
     |  
     |  weibullvariate(self, alpha, beta)
     |      Weibull distribution.
     |      
     |      alpha is the scale parameter and beta is the shape parameter.
     |  
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |  
     |  __init_subclass__(**kwargs)
     |      Control how subclasses generate random integers.
     |      
     |      The algorithm a subclass can use depends on the random() and/or
     |      getrandbits() implementation available to it and determines
     |      whether it can generate random integers from arbitrarily large
     |      ranges.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables
     |  
     |  __weakref__
     |      list of weak references to the object
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  VERSION = 3
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from _random.Random:
     |  
     |  getrandbits(self, k, /)
     |      getrandbits(k) -> x.  Generates an int with k random bits.
     |  
     |  random(self, /)
     |      random() -> x in the interval [0, 1).
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from _random.Random:
     |  
     |  __new__(*args, **kwargs) class method of _random.Random
     |      Create and return a new object.  See help(type) for accurate signature.
    
    class SystemRandom(Random)
     |  SystemRandom(x=None)
     |  
     |  Alternate random number generator using sources provided
     |  by the operating system (such as /dev/urandom on Unix or
     |  CryptGenRandom on Windows).
     |  
     |   Not available on all systems (see os.urandom() for details).
     |  
     |  Method resolution order:
     |      SystemRandom
     |      Random
     |      _random.Random
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  getrandbits(self, k)
     |      getrandbits(k) -> x.  Generates an int with k random bits.
     |  
     |  getstate = _notimplemented(self, *args, **kwds)
     |  
     |  randbytes(self, n)
     |      Generate n random bytes.
     |  
     |  random(self)
     |      Get the next random number in the range 0.0 <= X < 1.0.
     |  
     |  seed(self, *args, **kwds)
     |      Stub method.  Not used for a system random number generator.
     |  
     |  setstate = _notimplemented(self, *args, **kwds)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Random:
     |  
     |  __getstate__(self)
     |      Helper for pickle.
     |  
     |  __init__(self, x=None)
     |      Initialize an instance.
     |      
     |      Optional argument x controls seeding, as for Random.seed().
     |  
     |  __reduce__(self)
     |      Helper for pickle.
     |  
     |  __setstate__(self, state)
     |  
     |  betavariate(self, alpha, beta)
     |      Beta distribution.
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      Returned values range between 0 and 1.
     |  
     |  choice(self, seq)
     |      Choose a random element from a non-empty sequence.
     |  
     |  choices(self, population, weights=None, *, cum_weights=None, k=1)
     |      Return a k sized list of population elements chosen with replacement.
     |      
     |      If the relative weights or cumulative weights are not specified,
     |      the selections are made with equal probability.
     |  
     |  expovariate(self, lambd)
     |      Exponential distribution.
     |      
     |      lambd is 1.0 divided by the desired mean.  It should be
     |      nonzero.  (The parameter would be called "lambda", but that is
     |      a reserved word in Python.)  Returned values range from 0 to
     |      positive infinity if lambd is positive, and from negative
     |      infinity to 0 if lambd is negative.
     |  
     |  gammavariate(self, alpha, beta)
     |      Gamma distribution.  Not the gamma function!
     |      
     |      Conditions on the parameters are alpha > 0 and beta > 0.
     |      
     |      The probability distribution function is:
     |      
     |                  x ** (alpha - 1) * math.exp(-x / beta)
     |        pdf(x) =  --------------------------------------
     |                    math.gamma(alpha) * beta ** alpha
     |  
     |  gauss(self, mu=0.0, sigma=1.0)
     |      Gaussian distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.  This is
     |      slightly faster than the normalvariate() function.
     |      
     |      Not thread-safe without a lock around calls.
     |  
     |  lognormvariate(self, mu, sigma)
     |      Log normal distribution.
     |      
     |      If you take the natural logarithm of this distribution, you'll get a
     |      normal distribution with mean mu and standard deviation sigma.
     |      mu can have any value, and sigma must be greater than zero.
     |  
     |  normalvariate(self, mu=0.0, sigma=1.0)
     |      Normal distribution.
     |      
     |      mu is the mean, and sigma is the standard deviation.
     |  
     |  paretovariate(self, alpha)
     |      Pareto distribution.  alpha is the shape parameter.
     |  
     |  randint(self, a, b)
     |      Return random integer in range [a, b], including both end points.
     |  
     |  randrange(self, start, stop=None, step=1)
     |      Choose a random item from range(stop) or range(start, stop[, step]).
     |      
     |      Roughly equivalent to ``choice(range(start, stop, step))`` but
     |      supports arbitrarily large ranges and is optimized for common cases.
     |  
     |  sample(self, population, k, *, counts=None)
     |      Chooses k unique random elements from a population sequence.
     |      
     |      Returns a new list containing elements from the population while
     |      leaving the original population unchanged.  The resulting list is
     |      in selection order so that all sub-slices will also be valid random
     |      samples.  This allows raffle winners (the sample) to be partitioned
     |      into grand prize and second place winners (the subslices).
     |      
     |      Members of the population need not be hashable or unique.  If the
     |      population contains repeats, then each occurrence is a possible
     |      selection in the sample.
     |      
     |      Repeated elements can be specified one at a time or with the optional
     |      counts parameter.  For example:
     |      
     |          sample(['red', 'blue'], counts=[4, 2], k=5)
     |      
     |      is equivalent to:
     |      
     |          sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
     |      
     |      To choose a sample from a range of integers, use range() for the
     |      population argument.  This is especially fast and space efficient
     |      for sampling from a large population:
     |      
     |          sample(range(10000000), 60)
     |  
     |  shuffle(self, x)
     |      Shuffle list x in place, and return None.
     |  
     |  triangular(self, low=0.0, high=1.0, mode=None)
     |      Triangular distribution.
     |      
     |      Continuous distribution bounded by given lower and upper limits,
     |      and having a given mode value in-between.
     |      
     |      http://en.wikipedia.org/wiki/Triangular_distribution
     |  
     |  uniform(self, a, b)
     |      Get a random number in the range [a, b) or [a, b] depending on rounding.
     |  
     |  vonmisesvariate(self, mu, kappa)
     |      Circular data distribution.
     |      
     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and
     |      kappa is the concentration parameter, which must be greater than or
     |      equal to zero.  If kappa is equal to zero, this distribution reduces
     |      to a uniform random angle over the range 0 to 2*pi.
     |  
     |  weibullvariate(self, alpha, beta)
     |      Weibull distribution.
     |      
     |      alpha is the scale parameter and beta is the shape parameter.
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Random:
     |  
     |  __init_subclass__(**kwargs)
     |      Control how subclasses generate random integers.
     |      
     |      The algorithm a subclass can use depends on the random() and/or
     |      getrandbits() implementation available to it and determines
     |      whether it can generate random integers from arbitrarily large
     |      ranges.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Random:
     |  
     |  __dict__
     |      dictionary for instance variables
     |  
     |  __weakref__
     |      list of weak references to the object
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Random:
     |  
     |  VERSION = 3
     |  
     |  ----------------------------------------------------------------------
     |  Static methods inherited from _random.Random:
     |  
     |  __new__(*args, **kwargs) class method of _random.Random
     |      Create and return a new object.  See help(type) for accurate signature.

FUNCTIONS
    betavariate(alpha, beta) method of Random instance
        Beta distribution.
        
        Conditions on the parameters are alpha > 0 and beta > 0.
        Returned values range between 0 and 1.
    
    choice(seq) method of Random instance
        Choose a random element from a non-empty sequence.
    
    choices(population, weights=None, *, cum_weights=None, k=1) method of Random instance
        Return a k sized list of population elements chosen with replacement.
        
        If the relative weights or cumulative weights are not specified,
        the selections are made with equal probability.
    
    expovariate(lambd) method of Random instance
        Exponential distribution.
        
        lambd is 1.0 divided by the desired mean.  It should be
        nonzero.  (The parameter would be called "lambda", but that is
        a reserved word in Python.)  Returned values range from 0 to
        positive infinity if lambd is positive, and from negative
        infinity to 0 if lambd is negative.
    
    gammavariate(alpha, beta) method of Random instance
        Gamma distribution.  Not the gamma function!
        
        Conditions on the parameters are alpha > 0 and beta > 0.
        
        The probability distribution function is:
        
                    x ** (alpha - 1) * math.exp(-x / beta)
          pdf(x) =  --------------------------------------
                      math.gamma(alpha) * beta ** alpha
    
    gauss(mu=0.0, sigma=1.0) method of Random instance
        Gaussian distribution.
        
        mu is the mean, and sigma is the standard deviation.  This is
        slightly faster than the normalvariate() function.
        
        Not thread-safe without a lock around calls.
    
    getrandbits(k, /) method of Random instance
        getrandbits(k) -> x.  Generates an int with k random bits.
    
    getstate() method of Random instance
        Return internal state; can be passed to setstate() later.
    
    lognormvariate(mu, sigma) method of Random instance
        Log normal distribution.
        
        If you take the natural logarithm of this distribution, you'll get a
        normal distribution with mean mu and standard deviation sigma.
        mu can have any value, and sigma must be greater than zero.
    
    normalvariate(mu=0.0, sigma=1.0) method of Random instance
        Normal distribution.
        
        mu is the mean, and sigma is the standard deviation.
    
    paretovariate(alpha) method of Random instance
        Pareto distribution.  alpha is the shape parameter.
    
    randbytes(n) method of Random instance
        Generate n random bytes.
    
    randint(a, b) method of Random instance
        Return random integer in range [a, b], including both end points.
    
    random() method of Random instance
        random() -> x in the interval [0, 1).
    
    randrange(start, stop=None, step=1) method of Random instance
        Choose a random item from range(stop) or range(start, stop[, step]).
        
        Roughly equivalent to ``choice(range(start, stop, step))`` but
        supports arbitrarily large ranges and is optimized for common cases.
    
    sample(population, k, *, counts=None) method of Random instance
        Chooses k unique random elements from a population sequence.
        
        Returns a new list containing elements from the population while
        leaving the original population unchanged.  The resulting list is
        in selection order so that all sub-slices will also be valid random
        samples.  This allows raffle winners (the sample) to be partitioned
        into grand prize and second place winners (the subslices).
        
        Members of the population need not be hashable or unique.  If the
        population contains repeats, then each occurrence is a possible
        selection in the sample.
        
        Repeated elements can be specified one at a time or with the optional
        counts parameter.  For example:
        
            sample(['red', 'blue'], counts=[4, 2], k=5)
        
        is equivalent to:
        
            sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
        
        To choose a sample from a range of integers, use range() for the
        population argument.  This is especially fast and space efficient
        for sampling from a large population:
        
            sample(range(10000000), 60)
    
    seed(a=None, version=2) method of Random instance
        Initialize internal state from a seed.
        
        The only supported seed types are None, int, float,
        str, bytes, and bytearray.
        
        None or no argument seeds from current time or from an operating
        system specific randomness source if available.
        
        If *a* is an int, all bits are used.
        
        For version 2 (the default), all of the bits are used if *a* is a str,
        bytes, or bytearray.  For version 1 (provided for reproducing random
        sequences from older versions of Python), the algorithm for str and
        bytes generates a narrower range of seeds.
    
    setstate(state) method of Random instance
        Restore internal state from object returned by getstate().
    
    shuffle(x) method of Random instance
        Shuffle list x in place, and return None.
    
    triangular(low=0.0, high=1.0, mode=None) method of Random instance
        Triangular distribution.
        
        Continuous distribution bounded by given lower and upper limits,
        and having a given mode value in-between.
        
        http://en.wikipedia.org/wiki/Triangular_distribution
    
    uniform(a, b) method of Random instance
        Get a random number in the range [a, b) or [a, b] depending on rounding.
    
    vonmisesvariate(mu, kappa) method of Random instance
        Circular data distribution.
        
        mu is the mean angle, expressed in radians between 0 and 2*pi, and
        kappa is the concentration parameter, which must be greater than or
        equal to zero.  If kappa is equal to zero, this distribution reduces
        to a uniform random angle over the range 0 to 2*pi.
    
    weibullvariate(alpha, beta) method of Random instance
        Weibull distribution.
        
        alpha is the scale parameter and beta is the shape parameter.

DATA
    __all__ = ['Random', 'SystemRandom', 'betavariate', 'choice', 'choices...

FILE
    c:\users\pulki\anaconda3\envs\personal\lib\random.py

# help() will give detailed information.
# dir() will just list members of a module.

# Extra Members added by PVM for every Module :-

# For every module, PVM will add several prdefined variabled, which are internally used by PVM. Even these variables can be used by programmer based on his requirement.

# __doc__
# __file__
# __name__
# __loader__
# __package__

print(dir())

['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__vsc_ipynb_file__', '_dh', '_i', '_i1', '_i10', '_i11', '_i2', '_i3', '_i4', '_i5', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'a', 'add', 'b', 'exit', 'get_ipython', 'math', 'module1', 'open', 'product', 'quit', 'random']

print(__loader__)

None

print(__builtins__)

<module 'builtins' (built-in)>

print(__builtin__)

<module 'builtins' (built-in)>

print(__doc__)

Automatically created module for IPython interactive environment

print(__package__)

None

print(__vsc_ipynb_file__)

c:\Users\pulki\Python\python_fundamentals\65_Finding_Members_of_Modules.ipynb

# # __doc__ :-

# This variable holds documentation string.

""" This code is written by Pulkit Chahal """

print(__doc__)

 This code is written by Pulkit Chahal 

""" This code is written by Pulkit Chahal """
""" This code is written by Chahal """
""" This code is written by Pulkit """

print(__doc__)

 This code is written by Pulkit 

import math

print(math.__doc__)

This module provides access to the mathematical functions
defined by the C standard.

import random

print(random.__doc__)

Random variable generators.

    bytes
    -----
           uniform bytes (values between 0 and 255)

    integers
    --------
           uniform within range

    sequences
    ---------
           pick random element
           pick random sample
           pick weighted random sample
           generate random permutation

    distributions on the real line:
    ------------------------------
           uniform
           triangular
           normal (Gaussian)
           lognormal
           negative exponential
           gamma
           beta
           pareto
           Weibull

    distributions on the circle (angles 0 to 2pi)
    ---------------------------------------------
           circular uniform
           von Mises

General notes on the underlying Mersenne Twister core generator:

* The period is 2**19937-1.
* It is one of the most extensively tested generators in existence.
* The random() method is implemented in C, executes in a single Python step,
  and is, therefore, threadsafe.

# # __file__ :-

# To get the location of file.

print("File Name:", __file__)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[26], line 1
----> 1 print("File Name:", __file__)

NameError: name '__file__' is not defined

import os

print("Absolute Path:", os.path.abspath(__vsc_ipynb_file__))

Absolute Path: c:\Users\pulki\Python\python_fundamentals\65_Finding_Members_of_Modules.ipynb

print("Directory:", os.path.dirname(os.path.abspath(__vsc_ipynb_file__)))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[27], line 1
----> 1 print("Directory:", os.path.dirname(os.path.abspath(__vsc_ipynb_file__)))

NameError: name 'os' is not defined

# # __name__ :-

# py module1.py ===> Direct execution of module1.py
# py test.py ===> Indirect execution of module1.py

print(__name__)

__main__

import module1

print("test module")

test module

# Module1 file

print("Module1 Execution")

Module1 Execution

# __name__ ---> Magic Variable

# __name__
    # ===> Direct Execution : __main__
            # It means we are executing module1 as main program.

    # ===> Indirect Execution : modulename (module1)

# __name__ ===> __main__    (DE)
        # ===> module1      (IE)

if __name__ == '___main__':
    print('Executing Directly')
else:
    print('Executing Indiretly because of import statement')

Executing Indiretly because of import statement

# Module1 file
def f1():
    print("f1 function")


def f2():
    print("f2 function")


def f3():
    print("f3 function")


def f4():
    print("f4 function")


f1()
f2()
f3()
f4()

f1 function
f2 function
f3 function
f4 function

import module1

print("We required only some functions but not all")
module1.f1()

We required only some functions but not all
f1 function

# # Working with Random Module :-

# Random module contains several functions to generate random numbers.

# Developing Games
# Cryptography
# OTP
# Random password

# 1. random()
# 2. uniform()
# 3. randint()
# 4. randrange()
# 5. choice()

# 1. random() :-

# generate some float values between 0 and 1 (not inclusive)

# 0.9999345
# 0.1234878

from random import *

print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())
print(random())

0.6464542100401829
0.010675848165000446
0.626119271169842
0.9968781442082784
0.008614968664742984
0.589771783023502
0.409783533525354
0.8431020634036197
0.48870048075470374
0.3819780839674809
0.12230734210818128

# 2. uniform() :-

# To generate random float vlaue between 2 given numbers (not inclusive)

# uniform(1,10)

from random import *

for i in range(10):
    print(uniform(1, 10))

3.1347665605027677
6.814167460300179
9.507224080637071
7.45048372921796
1.670982266184999
5.7269930756381235
2.172093103180653
2.317205953537269
4.6647954685826205
5.140179460010281

# 3. randint() :-

# To generate a random interger between 2 given numbers (inclusive)

# randint(1, 10) ---> 1 to 10 including 1 and 10

from random import *

for i in range(10):
    print(randint(1, 10))

1
5
8
7
7
5
1
10
5
3

# 4. randrange([begin], end, [step]) :-

# Returns a random number from range
    # begin <= x < end

# begin is optional and default value is 0.
# step is optional and default value is 1.

# randrane(10) ---> generates a random number from 0 to 9
# randrange(1, 10) ---> generates a random number from 1 to 10
# randrange(1, 11, 2) ---> generates a random number from 1 to 10 by increment of 2
                        # [1, 3, 5, 7, 9]

# randrange(0, 11, 2) ---> generates a random number from 0 to 10 by increment of 2
                        # [0, 2, 4, 6, 8]

from random import *

for i in range(10):
    print(randrange(10))

8
1
1
5
5
9
6
7
4
6

from random import *

for i in range(10):
    print(randrange(1, 11))

4
3
2
4
5
7
6
8
3
2

from random import *

for i in range(10):
    print(randrange(1, 11, 2))

5
3
3
1
3
3
5
3
7
5

from random import *

for i in range(10):
    print(randrange(0, 11, 2))

2
2
10
0
0
6
10
0
6
8

# 5. choice() :-

# It won't generate random number.
# It will generate a random object from the given sequence.

from random import *

l = ["Sunny", "Bunny", "Chinny", "Vinny", "Pinny"]

for i in range(10):
    print(choice(l))

Vinny
Chinny
Pinny
Bunny
Chinny
Pinny
Sunny
Pinny
Pinny
Sunny

from random import *

alphabets = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

for i in range(10):
    print(choice(alphabets))

S
W
W
K
Y
G
n
y
a
B

# 1. To genrate 6-digit random number which can be used as OTP?

from random import *

print(
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
)

5 4 0 4 5 3

from random import *

print(
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    randint(0, 9),
    sep="",
)

092666

from random import *

for i in range(10):
    print(
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        randint(0, 9),
        sep="",
    )

239368
411586
955018
891601
161595
783737
720103
579960
681697
663860

# 2. Random pwd of 6 length?

# where 1, 3, 5 are alphabet symbols
# 2, 4, 6 are digits

from random import *

alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
digits = "0123456789"

for i in range(10):
    print(
        choice(alphabets)
        + choice(digits)
        + choice(alphabets)
        + choice(digits)
        + choice(alphabets)
        + choice(digits)
    )

B2E3X5
H2H4F1
T1Y7F0
V0M0H4
G1G4E6
V4A5S8
P7J2S1
W0T9N3
L7B5X5
O1U3M0

from random import *

alphabets = "abcdefghijklmnopqrstuvwxyz"
digits = "0123456789"
cities = ["Hyderabad", "Chennai", "Banglore", "Pune", "Delhi", "Mumbai"]
designations = [
    "Software Engineer",
    "Senior Software Engineer",
    "Team Lead",
    "Project Manager",
    "Project Lead",
]


def get_fake_name():
    name = choice(alphabets).upper()
    n = randint(2, 6)
    for i in range(n):
        name = name + choice(alphabets)
    return name


def get_fake_eno():
    eno = "e-"
    for i in range(4):
        eno = eno + str(randint(0, 9))
    return eno


def get_fake_salary():
    esal = uniform(10000, 50000)
    return esal


def get_fake_city():
    city = choice(cities)
    return city


def get_fake_mno():
    mno = choice("6789")
    for i in range(9):
        mno = mno + choice(digits)
    return mno


def get_fake_designation():
    designation = choice(designations)
    return designation


def get_fake_emp_data():
    print("Employee Name :", get_fake_name())
    print("Employee Number :", get_fake_eno())
    print("Employee Salary : {:.2f}".format(get_fake_salary()))
    print("Employee City :", get_fake_city())
    print("Employee Mobile Number :", get_fake_mno())
    print("Employee Designation :", get_fake_designation())


get_fake_emp_data()

Employee Name : Wefp
Employee Number : e-0714
Employee Salary : 26959.20
Employee City : Mumbai
Employee Mobile Number : 7147705020
Employee Designation : Project Lead

for i in range(3):
    get_fake_emp_data()

Employee Name : Blysth
Employee Number : e-8084
Employee Salary : 18230.72
Employee City : Banglore
Employee Mobile Number : 7672497334
Employee Designation : Project Lead
Employee Name : Cdxvdsr
Employee Number : e-8162
Employee Salary : 10383.68
Employee City : Pune
Employee Mobile Number : 8985711489
Employee Designation : Project Lead
Employee Name : Axaz
Employee Number : e-1870
Employee Salary : 16295.46
Employee City : Delhi
Employee Mobile Number : 6993463914
Employee Designation : Team Lead

# # Working with Math Module :-

# Math module defines several functions which can be used for mathematical operations.

# sqrt(x)
# ceil(x)
# floor(x)
# fabs(x)
# log(x)
# sin(x)
# tan(x)

from math import *

print(sqrt(4))

2.0

print(ceil(10.1))

11

print(ceil(10.5))

11

print(floor(10.1))

10

print(floor(10.4))

10

print(floor(10.5))

10

print(floor(10.6))

10

print(fabs(10.6))

10.6

print(fabs(-10.6))

10.6

import math

help(math)

Help on built-in module math:

NAME
    math

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.
        
        The result is between 0 and pi.
    
    acosh(x, /)
        Return the inverse hyperbolic cosine of x.
    
    asin(x, /)
        Return the arc sine (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    asinh(x, /)
        Return the inverse hyperbolic sine of x.
    
    atan(x, /)
        Return the arc tangent (measured in radians) of x.
        
        The result is between -pi/2 and pi/2.
    
    atan2(y, x, /)
        Return the arc tangent (measured in radians) of y/x.
        
        Unlike atan(y/x), the signs of both x and y are considered.
    
    atanh(x, /)
        Return the inverse hyperbolic tangent of x.
    
    cbrt(x, /)
        Return the cube root of x.
    
    ceil(x, /)
        Return the ceiling of x as an Integral.
        
        This is the smallest integer >= x.
    
    comb(n, k, /)
        Number of ways to choose k items from n items without repetition and without order.
        
        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates
        to zero when k > n.
        
        Also called the binomial coefficient because it is equivalent
        to the coefficient of k-th term in polynomial expansion of the
        expression (1 + x)**n.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    copysign(x, y, /)
        Return a float with the magnitude (absolute value) of x but the sign of y.
        
        On platforms that support signed zeros, copysign(1.0, -0.0)
        returns -1.0.
    
    cos(x, /)
        Return the cosine of x (measured in radians).
    
    cosh(x, /)
        Return the hyperbolic cosine of x.
    
    degrees(x, /)
        Convert angle x from radians to degrees.
    
    dist(p, q, /)
        Return the Euclidean distance between two points p and q.
        
        The points should be specified as sequences (or iterables) of
        coordinates.  Both inputs must have the same dimension.
        
        Roughly equivalent to:
            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))
    
    erf(x, /)
        Error function at x.
    
    erfc(x, /)
        Complementary error function at x.
    
    exp(x, /)
        Return e raised to the power of x.
    
    exp2(x, /)
        Return 2 raised to the power of x.
    
    expm1(x, /)
        Return exp(x)-1.
        
        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
    
    fabs(x, /)
        Return the absolute value of the float x.
    
    factorial(n, /)
        Find n!.
        
        Raise a ValueError if x is negative or non-integral.
    
    floor(x, /)
        Return the floor of x as an Integral.
        
        This is the largest integer <= x.
    
    fmod(x, y, /)
        Return fmod(x, y), according to platform C.
        
        x % y may differ.
    
    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).
        
        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
    
    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.
        
        Assumes IEEE-754 floating point arithmetic.
    
    gamma(x, /)
        Gamma function at x.
    
    gcd(*integers)
        Greatest Common Divisor.
    
    hypot(...)
        hypot(*coordinates) -> value
        
        Multidimensional Euclidean distance from the origin to a point.
        
        Roughly equivalent to:
            sqrt(sum(x**2 for x in coordinates))
        
        For a two dimensional point (x, y), gives the hypotenuse
        using the Pythagorean theorem:  sqrt(x*x + y*y).
        
        For example, the hypotenuse of a 3/4/5 right triangle is:
        
            >>> hypot(3.0, 4.0)
            5.0
    
    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
        Determine whether two floating point numbers are close in value.
        
          rel_tol
            maximum difference for being considered "close", relative to the
            magnitude of the input values
          abs_tol
            maximum difference for being considered "close", regardless of the
            magnitude of the input values
        
        Return True if a is close in value to b, and False otherwise.
        
        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.
        
        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
        is, NaN is not close to anything, even itself.  inf and -inf are
        only close to themselves.
    
    isfinite(x, /)
        Return True if x is neither an infinity nor a NaN, and False otherwise.
    
    isinf(x, /)
        Return True if x is a positive or negative infinity, and False otherwise.
    
    isnan(x, /)
        Return True if x is a NaN (not a number), and False otherwise.
    
    isqrt(n, /)
        Return the integer part of the square root of the input.
    
    lcm(*integers)
        Least Common Multiple.
    
    ldexp(x, i, /)
        Return x * (2**i).
        
        This is essentially the inverse of frexp().
    
    lgamma(x, /)
        Natural logarithm of absolute value of Gamma function at x.
    
    log(...)
        log(x, [base=math.e])
        Return the logarithm of x to the given base.
        
        If the base not specified, returns the natural logarithm (base e) of x.
    
    log10(x, /)
        Return the base 10 logarithm of x.
    
    log1p(x, /)
        Return the natural logarithm of 1+x (base e).
        
        The result is computed in a way which is accurate for x near zero.
    
    log2(x, /)
        Return the base 2 logarithm of x.
    
    modf(x, /)
        Return the fractional and integer parts of x.
        
        Both results carry the sign of x and are floats.
    
    nextafter(x, y, /)
        Return the next floating-point value after x towards y.
    
    perm(n, k=None, /)
        Number of ways to choose k items from n items without repetition and with order.
        
        Evaluates to n! / (n - k)! when k <= n and evaluates
        to zero when k > n.
        
        If k is not specified or is None, then k defaults to n
        and the function returns n!.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    pow(x, y, /)
        Return x**y (x to the power of y).
    
    prod(iterable, /, *, start=1)
        Calculate the product of all the elements in the input iterable.
        
        The default start value for the product is 1.
        
        When the iterable is empty, return the start value.  This function is
        intended specifically for use with numeric values and may reject
        non-numeric types.
    
    radians(x, /)
        Convert angle x from degrees to radians.
    
    remainder(x, y, /)
        Difference between x and the closest integer multiple of y.
        
        Return x - n*y where n*y is the closest integer multiple of y.
        In the case where x is exactly halfway between two multiples of
        y, the nearest even value of n is used. The result is always exact.
    
    sin(x, /)
        Return the sine of x (measured in radians).
    
    sinh(x, /)
        Return the hyperbolic sine of x.
    
    sqrt(x, /)
        Return the square root of x.
    
    tan(x, /)
        Return the tangent of x (measured in radians).
    
    tanh(x, /)
        Return the hyperbolic tangent of x.
    
    trunc(x, /)
        Truncates the Real x to the nearest Integral toward 0.
        
        Uses the __trunc__ magic method.
    
    ulp(x, /)
        Return the value of the least significant bit of the float x.

DATA
    e = 2.718281828459045
    inf = inf
    nan = nan
    pi = 3.141592653589793
    tau = 6.283185307179586

FILE
    (built-in)

a = -12.99

print(floor(fabs(a)))

12

a = -12.99

print(fabs(floor(a)))

13.0

import math

l = [str(round(math.pi)) for i in range(1, 6)]
print(l)

['3', '3', '3', '3', '3']

round(3.4)

3

round(3.5)

4

round(3.6)

4

# Modules :-
    # random
    # selenium
    # faker
    # math
    # os
    # re

# Functions :-
    # A group of repeatedly required lines
    # Code Reusability

# Modules :-
    # Python File
    # A group of functions, varibales, classes saved to a file

# # Packages :-

# Basic Java Package
    # core java + advanced java + oracle

# Complete Python Package
    # Core Python + Advanced Python + UI + Django + Django Rest Framework + Microsoft Certification

# Complete Body Checkup Package

# Hear Checkup Package

# South India Tour Package
    # 10 places

# A collection of python lines into a single unit ---> Function

# A collection of python functions, variable and classes into a single file ---> Module

# A collection of related modules into a folder ---> Package

# A collection of related modules into a single unit is nothing but package.

# Package is an encapsulation mechansim to group related modules into a single unit.

# Package is simply a folder or directory.

# If folder contains __init__.py file is considered as python package.

# A python package can contains sub package also but all packages should contain __init__.py file.

# From Python 3.3 version onwards, it is not mandatory to have __init__.py file.

# Advantages of Packages :-
    # 1. We can resolve naming conflicts.
    # 2. We can identify our components uniquely.
    # 3. It imporoves modularity of the application.
    # 4. It improves readability and maintainability of the applications.

# C:\Python
    # |-test.py
    # |-com
        # |-__init__.py
        # |-module1.py (contains f1 function)
        # |-durgasoft
            # |-__init__.py
            # |-module2.py (contains f2 function)

# from com.module1 import f1

# f1()

# from com.durgasoft.module2 import f2

# f2()

# Importance of init.py File :-

# At the time of using a package, if we want to perform any initialization activites automatically then we have to go for __init__.py

# but if we write print statement in noraml module also it will be executed? 
# but we have to call the function in which print statement while in __init__.py it will be executed automatically.

# If we have __init__.py file in folder and subfolder then.

# when we call folder then only folder __init__.py will execute
    # ex. from com.module import f1
        # in this only folder __init__.py file will execute automatically

# when we call sub-folder then folder and sub-folder __init__.py will execute
    # ex. from com.durgasoft.module2 import f1
        # in this folder and sub-folder __init__.py file will execute automatically

# Need of Installing a Package :-

# If we wnat to use a package, compulsory it should be available in the current working directory.

# To make package available through out our system then we have to install that package. Once we installed we can access that package from anywhere in our system.

# exec('function_name')

# How to Install Package :-

# from setuptools import setup

# setup(name="patterns", version="1.0", packages=["patterns"])

# pip is a python package management system to install and manage software packages written in python.

# pip install .

# # Alternative Way :-

# from setuptools import setup, find_packages

# setup(name="patterns", version="1.0", packages=find_packages())

# pip uninstall patterns

# pip install django (installing django library)
# pip install pymysql
# pip install selenium (for automation)

# pip ---> python package management software system
# npm ---> javascript
# apt ---> Ubuntu
# yum ---> redhat linux

# # Library vs Package vs Module vs Function :-

# Function ---> A group of repeatedly required lines of code.
# Module ---> A group of repeatedly required functions, variables, classes saved to a file.
# Package ---> A group of related modules into a single folder. It contains sub packages.
# Library ---> A group of packages.

# # File Handling :-

# We required to store data
    # student marks
    # customers account information
    # billing information

# Files are very common permanent storage areas to store our data.

# list, tuple, set, dict ===> available as long as program is in running. Once program completes these objects will be destroyed automatically and hence the data will be gone. Temporary storage areas.

d = {}

for i in range(3):
    name = input("Enter Name :")
    balance = int(input("Enter Balance :"))
    d[name] = balance

print(d)

{'asdbj': 45, 'dsafda': 2452, 'asdfas4': 24}

# Permanent Storage Areas :-
    # files
    # database
    # big data technologies/cloud

# Types of Files :-

# 2 Types of Files :-
    # 1. text files :
        # abc.txt, test.py

    # 2. Binary Files:
        # images, video files, audio files etc

# Opening of a File :-

# f = open(filename, mode)

# Example :-

f = open("abc.txt", "r")
data = f.read()
print(data)

This is Python Practice

# # The allowed modes are:
    # r, w, a, r+, w+, a+, x

# 1. r :-

# Open an existing file for read operation. The file pointer is at begining of the file.
# FileNotFoundError
# default mode is red mode

# 2. w :-

# Open an existing file for write operation.
# Overwrite of existing data will be happened.
# If the specified file not already availabel, then this mode will create that file.

f = open('abc.txt', 'w')

# 3. a :-

# Open an existing file for append operation.
# It won't overwrite of existing data will be happened.
# If the specified file not already availabel, then this mode will create that file.

# 4. r+ :-

# To read and write data.
# The previous data won't be overwritten.

# 5. w+ :-

# To write and read data.
# It will overwrite existing data.

# 6. a+ :-

# It append and read.
# It won't overwrite existing data.

# 7. x :-

# To open a file in exclusive createion mode.
# Specified file should not be avaialable already, otherwise we will get FileExistsError

# # 2. Binary File :-

# rb
# wb
# ab
# r+b
# w+b
# a+b
# xb

# Closing of a File :-

f.close()

# Various Properties of File Object :-

f = open("abc.txt", "r")

# f.name ---> Name of opened File
# f.module ---> Mode in which we opened that file.
# f.closed ---> Is the file closed (True/False)
# f.readable() ---> Returns True if the file is readable
# f.wrtable() ---> Returns True if the file is writable

f = open("abc.txt", "r")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : r
Is File Readable : True
Is File Writable : False
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "w")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : w
Is File Readable : False
Is File Writable : True
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "r+")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : r+
Is File Readable : True
Is File Writable : True
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "w+")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : w+
Is File Readable : True
Is File Writable : True
Is File Closed : False
Is File Closed : True

f = open("abc.txt", "a")

print("File Name :", f.name)
print("File Mode :", f.mode)
print("Is File Readable :", f.readable())
print("Is File Writable :", f.writable())
print("Is File Closed :", f.closed)
f.close()
print("Is File Closed :", f.closed)

File Name : abc.txt
File Mode : a
Is File Readable : False
Is File Writable : True
Is File Closed : False
Is File Closed : True

# Write Data to the text Files :-

# 2 METHODS :-
    # f.write(str)
    # f.writelines(list of lines)

f = open("abc.txt", "w")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w+")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "r+")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

# Data will be written in existing file without resenting file

f = open("abc.txt", "a+")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

# Data will be written in existing file without resenting file

f = open("abc.txt", "a")
f.write("Durga\n")
f.write("Software\n")
f.write("Solutions\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "x")

f.write("Durga ")
f.write("Software ")
f.write("Solutions ")
print("Data Written to the File Successfully")
f.close()

---------------------------------------------------------------------------
FileExistsError                           Traceback (most recent call last)
Cell In[18], line 1
----> 1 f = open("abc.txt", "x")
      3 f.write("Durga ")
      4 f.write("Software ")

File c:\Users\pulki\anaconda3\envs\Personal\Lib\site-packages\IPython\core\interactiveshell.py:324, in _modified_open(file, *args, **kwargs)
    317 if file in {0, 1, 2}:
    318     raise ValueError(
    319         f"IPython won't let you open fd={file} by default "
    320         "as it is likely to crash IPython. If you know what you are doing, "
    321         "you can use builtins' open."
    322     )
--> 324 return io_open(file, *args, **kwargs)

FileExistsError: [Errno 17] File exists: 'abc.txt'

# f.writelines(list of lines) :-

f = open("abc.txt", "w")
l = ["Bunny", "Chinny", "Sunny", "Pinny", "Vinny"]

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w")
l = ["Bunny\n", "Chinny\n", "Sunny\n", "Pinny\n", "Vinny\n"]

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

# write(str)

# multiple strings ---> multiple write() methods
# writelines(list|ste|tuple|dict)

f = open("abc.txt", "w")
l = ("Bunny\n", "Chinny\n", "Sunny\n", "Pinny\n", "Vinny")

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w")
l = {"Bunny\n", "Chinny\n", "Sunny\n", "Pinny\n", "Vinny"}

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

# for set order wise no guaranttee

Data Written to the File Successfully

f = open("abc.txt", "w")
l = {"A": 100, "B": 200, "C": 300}

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

f = open("abc.txt", "w")
l = {100: "A", 200: "B", 300: "C"}

f.writelines(l)

print("Data Written to the File Successfully")
f.close()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[28], line 4
      1 f = open("abc.txt", "w")
      2 l = {100: "A", 200: "B", 300: "C"}
----> 4 f.writelines(l)
      6 print("Data Written to the File Successfully")
      7 f.close()

TypeError: write() argument must be str, not int

f = open("C:\\GNA\\abc.txt", "w")

f.write("First Line\n")
f.write("Second Line\n")
f.write("Third Line\n")
print("Data Written to the File Successfully")
f.close()

Data Written to the File Successfully

fname = input("Enter File Name:")
f = open("C:\\GNA\\" + fname + ".txt", "w")

while True:
    data = input("Enter Data to Write:")
    f.write(data + "\n")
    option = input("Do you want to add some more data[Yes|No]:")
    if option.lower() == "no":
        break

print("Your Provided Data Written to the File Successfully")

f = open("C:\\GNA\\" + fname + ".txt", "r")
print(f.read())

f.close()

Your Provided Data Written to the File Successfully
durga
software
solutions

# Reading Data from Files :-

# read()    ---> To read total data from the file
# read(n)   ---> To read n characters from the file
# readline()    ---> To read only one line
# readlines()   ---> To read all lines into a list

f = open("abc.txt", "r")
data = f.read()
print(data)

Sunny
Bunny
Chinny
Vinny
Pinny
Munny

f = open("abc.txt", "r")
data = f.read(10)
print(data)

Sunny
Bunn

f = open("abc.txt", "r")
data = f.readline()
print(data)

Sunny

f = open("abc.txt", "r")
data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

data = f.readline()
print(data)

Sunny

Bunny

Chinny

Vinny

Pinny

Munny

data = f.readline()
print(data)

data = f.readline()
print(data)

# After lines are finished while using f.readline() then it will keep on reading/printing empty lines.

# f.readline() will automatically add new empty line after each new line.

f = open("abc.txt", "r")
data = f.readlines()
print(data)

['Sunny\n', 'Bunny\n', 'Chinny\n', 'Vinny\n', 'Pinny\n', 'Munny']

f = open("abc.txt", "r")

line = f.readline()
while line != "":
    print(line)
    line = f.readline()

f.close()

Sunny

Bunny

Chinny



Vinny

Pinny

Munny

f = open("abc.txt", "r")

line = f.readline()
while line != "":
    print(line, end="")
    line = f.readline()

f.close()

Sunny
Bunny
Chinny

Vinny
Pinny
Munny

f = open("abc.txt", "r")

line = f.readline()
while line != "":
    if line != "\n":
        print(line, end="")
    line = f.readline()

f.close()

Sunny
Bunny
Chinny
Vinny
Pinny
Munny

f = open("abc.txt", "r")
data = f.readlines()
print(data)

['Sunny\n', 'Bunny\n', 'Chinny\n', '\n', 'Vinny\n', 'Pinny\n', 'Munny']

f = open("abc.txt", "r")
data = f.readlines()
print(data)

for line in data:
    print(line)

['Sunny\n', 'Bunny\n', 'Chinny\n', '\n', 'Vinny\n', 'Pinny\n', 'Munny']
Sunny

Bunny

Chinny



Vinny

Pinny

Munny

f = open("abc.txt", "r")
data = f.readlines()
print(data)

for line in data:
    print(line, end="")

['Sunny\n', 'Bunny\n', 'Chinny\n', '\n', 'Vinny\n', 'Pinny\n', 'Munny']
Sunny
Bunny
Chinny

Vinny
Pinny
Munny

f = open("abc.txt", "r")

print(f.read(3))
print(f.readline())
print(f.read(4))
print(f.read())

Sun
ny

Bunn
y
Chinny

Vinny
Pinny
Munny

# Read data from input.txt and write to output.txt?

f1 = open("input.txt", "r")
f2 = open("output.txt", "w")

data = f1.read()
f2.write(data)

f1.close()
f2.close()

print("Data Copied Successfully")

Data Copied Successfully

# with statement :-

with open("abc.txt", "w") as f:
    f.write("DURGA\n")
    f.write("SOFTWARE\n")
    f.write("SOLUTIONS\n")
    print("Is File Closed:", f.closed)

print("Is File Closed:", f.closed)

Is File Closed: False
Is File Closed: True

# When we use with statement file will be closed automatically we are not required to close the file.

# The file will close automatically when we are out of with statement.

f1 = open("abc.txt", "w")
f2 = open("abc.txt", "a")

f2.write("hello")
f1.write("Hi")

f2.close()
f1.close()

with open("abc.txt", "r") as f:
    print(f.read())

Hihellohello

# # Advantages of with statement :-
    # 1. To group file operation in a block
    # 2. To close the file automatically